From ae1f47e3e5d6705b6b12997bd036fd97303d71d7 Mon Sep 17 00:00:00 2001 From: oxalica Date: Sun, 22 Sep 2024 11:24:53 -0400 Subject: [PATCH 001/131] Mark #[automatically_derived] for generated impls --- impl/src/expand.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 296b567..403cd07 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -36,6 +36,7 @@ fn fallback(input: &DeriveInput, error: syn::Error) -> TokenStream { #error #[allow(unused_qualifications)] + #[automatically_derived] impl #impl_generics std::error::Error for #ty #ty_generics #where_clause where // Work around trivial bounds being unstable. @@ -44,6 +45,7 @@ fn fallback(input: &DeriveInput, error: syn::Error) -> TokenStream { {} #[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!() @@ -178,6 +180,7 @@ fn impl_struct(input: Struct) -> TokenStream { let display_where_clause = display_inferred_bounds.augment_where_clause(input.generics); quote! { #[allow(unused_qualifications)] + #[automatically_derived] impl #impl_generics ::core::fmt::Display for #ty #ty_generics #display_where_clause { #[allow(clippy::used_underscore_binding)] fn fmt(&self, __formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { @@ -193,6 +196,7 @@ fn impl_struct(input: Struct) -> TokenStream { let body = from_initializer(from_field, backtrace_field); quote! { #[allow(unused_qualifications)] + #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { #[allow(deprecated)] fn from(source: #from) -> Self { @@ -211,6 +215,7 @@ fn impl_struct(input: Struct) -> TokenStream { quote! { #[allow(unused_qualifications)] + #[automatically_derived] impl #impl_generics std::error::Error for #ty #ty_generics #error_where_clause { #source_method #provide_method @@ -427,6 +432,7 @@ fn impl_enum(input: Enum) -> TokenStream { let display_where_clause = display_inferred_bounds.augment_where_clause(input.generics); Some(quote! { #[allow(unused_qualifications)] + #[automatically_derived] impl #impl_generics ::core::fmt::Display for #ty #ty_generics #display_where_clause { fn fmt(&self, __formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { #use_as_display @@ -449,6 +455,7 @@ fn impl_enum(input: Enum) -> TokenStream { let body = from_initializer(from_field, backtrace_field); Some(quote! { #[allow(unused_qualifications)] + #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { #[allow(deprecated)] fn from(source: #from) -> Self { @@ -467,6 +474,7 @@ fn impl_enum(input: Enum) -> TokenStream { quote! { #[allow(unused_qualifications)] + #[automatically_derived] impl #impl_generics std::error::Error for #ty #ty_generics #error_where_clause { #source_method #provide_method From 84484bc75c20d63ec63299354b463407f3d59f68 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 22 Sep 2024 10:53:10 -0700 Subject: [PATCH 002/131] Release 1.0.64 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 71f1008..1d1f8b0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "1.0.63" +version = "1.0.64" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -12,7 +12,7 @@ repository = "https://github.com/dtolnay/thiserror" rust-version = "1.56" [dependencies] -thiserror-impl = { version = "=1.0.63", path = "impl" } +thiserror-impl = { version = "=1.0.64", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index cafcd02..4195d57 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "1.0.63" +version = "1.0.64" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 42dd65b..92d3c5d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -258,7 +258,7 @@ //! //! [`anyhow`]: https://github.com/dtolnay/anyhow -#![doc(html_root_url = "https://docs.rs/thiserror/1.0.63")] +#![doc(html_root_url = "https://docs.rs/thiserror/1.0.64")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 1b15d6e6a44cd32d3622864ee6a77097a51df185 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 7 Oct 2024 00:14:29 +0200 Subject: [PATCH 003/131] Ignore needless_lifetimes clippy lint warning: the following explicit lifetimes could be elided: 'a --> tests/test_display.rs:152:14 | 152 | impl<'a> Display for Msg<'a> { | ^^ ^^ | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes = note: `-W clippy::needless-lifetimes` implied by `-W clippy::all` = help: to override `-W clippy::all` add `#[allow(clippy::needless_lifetimes)]` help: elide the lifetimes | 152 - impl<'a> Display for Msg<'a> { 152 + impl Display for Msg<'_> { | --- tests/test_display.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/test_display.rs b/tests/test_display.rs index 7a9057c..89bdc4a 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -1,4 +1,8 @@ -#![allow(clippy::needless_raw_string_hashes, clippy::uninlined_format_args)] +#![allow( + clippy::needless_lifetimes, + clippy::needless_raw_string_hashes, + clippy::uninlined_format_args +)] use core::fmt::{self, Display}; use thiserror::Error; From a72ea77c457bd4e150e8de93b33d8258f1908feb Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 7 Oct 2024 00:15:12 +0200 Subject: [PATCH 004/131] Resolve extra_unused_lifetimes clippy lint warning: this lifetime isn't used in the impl --> src/aserror.rs:46:6 | 46 | impl<'a, T: Error + 'a> Sealed for T {} | ^^ | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes = note: `-W clippy::extra-unused-lifetimes` implied by `-W clippy::all` = help: to override `-W clippy::all` add `#[allow(clippy::extra_unused_lifetimes)]` --- src/aserror.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/aserror.rs b/src/aserror.rs index 11cb4d9..1bced57 100644 --- a/src/aserror.rs +++ b/src/aserror.rs @@ -43,7 +43,7 @@ impl<'a> AsDynError<'a> for dyn Error + Send + Sync + UnwindSafe + 'a { #[doc(hidden)] pub trait Sealed {} -impl<'a, T: Error + 'a> Sealed for T {} +impl Sealed for T {} impl<'a> Sealed for dyn Error + 'a {} impl<'a> Sealed for dyn Error + Send + 'a {} impl<'a> Sealed for dyn Error + Send + Sync + 'a {} From f563b1dc7620304c797cb794ba6e45fcba2b7586 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 22 Oct 2024 10:46:24 -0700 Subject: [PATCH 005/131] Clean up dep-info files from OUT_DIR --- build.rs | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/build.rs b/build.rs index d619631..51ac436 100644 --- a/build.rs +++ b/build.rs @@ -1,5 +1,7 @@ use std::env; use std::ffi::OsString; +use std::fs; +use std::io::ErrorKind; use std::iter; use std::path::Path; use std::process::{self, Command, Stdio}; @@ -68,8 +70,16 @@ fn compile_probe(rustc_bootstrap: bool) -> bool { let rustc = cargo_env_var("RUSTC"); let out_dir = cargo_env_var("OUT_DIR"); + let out_subdir = Path::new(&out_dir).join("probe"); let probefile = Path::new("build").join("probe.rs"); + if let Err(err) = fs::create_dir(&out_subdir) { + if err.kind() != ErrorKind::AlreadyExists { + eprintln!("Failed to create {}: {}", out_subdir.display(), err); + process::exit(1); + } + } + let rustc_wrapper = env::var_os("RUSTC_WRAPPER").filter(|wrapper| !wrapper.is_empty()); let rustc_workspace_wrapper = env::var_os("RUSTC_WORKSPACE_WRAPPER").filter(|wrapper| !wrapper.is_empty()); @@ -91,7 +101,7 @@ fn compile_probe(rustc_bootstrap: bool) -> bool { .arg("--cap-lints=allow") .arg("--emit=dep-info,metadata") .arg("--out-dir") - .arg(out_dir) + .arg(&out_subdir) .arg(probefile); if let Some(target) = env::var_os("TARGET") { @@ -107,10 +117,22 @@ fn compile_probe(rustc_bootstrap: bool) -> bool { } } - match cmd.status() { + let success = match cmd.status() { Ok(status) => status.success(), Err(_) => false, + }; + + // Clean up to avoid leaving nondeterministic absolute paths in the dep-info + // file in OUT_DIR, which causes nonreproducible builds in build systems + // that treat the entire OUT_DIR as an artifact. + if let Err(err) = fs::remove_dir_all(&out_subdir) { + if err.kind() != ErrorKind::NotFound { + eprintln!("Failed to clean up {}: {}", out_subdir.display(), err); + process::exit(1); + } } + + success } fn cargo_env_var(key: &str) -> OsString { From 5088592a4efb6a5c40b4d869eb1a0e2eacf622cb Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 22 Oct 2024 10:50:31 -0700 Subject: [PATCH 006/131] Release 1.0.65 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 1d1f8b0..4ed2173 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "1.0.64" +version = "1.0.65" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -12,7 +12,7 @@ repository = "https://github.com/dtolnay/thiserror" rust-version = "1.56" [dependencies] -thiserror-impl = { version = "=1.0.64", path = "impl" } +thiserror-impl = { version = "=1.0.65", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 4195d57..fc0a53b 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "1.0.64" +version = "1.0.65" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 92d3c5d..15872e3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -258,7 +258,7 @@ //! //! [`anyhow`]: https://github.com/dtolnay/anyhow -#![doc(html_root_url = "https://docs.rs/thiserror/1.0.64")] +#![doc(html_root_url = "https://docs.rs/thiserror/1.0.65")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 010c2d81e9930b21d9ea1d4807a6da4f7edac66e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 24 Oct 2024 17:43:57 -0700 Subject: [PATCH 007/131] Seal the private AsDisplay trait --- src/display.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/display.rs b/src/display.rs index 3c43216..7a62ae2 100644 --- a/src/display.rs +++ b/src/display.rs @@ -2,7 +2,7 @@ use core::fmt::Display; use std::path::{self, Path, PathBuf}; #[doc(hidden)] -pub trait AsDisplay<'a> { +pub trait AsDisplay<'a>: Sealed { // TODO: convert to generic associated type. // https://github.com/dtolnay/thiserror/pull/253 type Target: Display; @@ -38,3 +38,9 @@ impl<'a> AsDisplay<'a> for PathBuf { self.display() } } + +#[doc(hidden)] +pub trait Sealed {} +impl Sealed for &T {} +impl Sealed for Path {} +impl Sealed for PathBuf {} From 5d3edf9d7e57f8a3080b12f96ab7f1f6e491061e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 14:25:18 -0700 Subject: [PATCH 008/131] Improve error on malformed format attribute --- impl/src/attr.rs | 12 ++++++++---- tests/ui/concat-display.stderr | 2 +- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/impl/src/attr.rs b/impl/src/attr.rs index e0ac02b..e59b519 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -91,7 +91,11 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu syn::custom_keyword!(transparent); attr.parse_args_with(|input: ParseStream| { - if let Some(kw) = input.parse::>()? { + let lookahead = input.lookahead1(); + let fmt = if lookahead.peek(LitStr) { + input.parse::()? + } else if lookahead.peek(transparent) { + let kw: transparent = input.parse()?; if attrs.transparent.is_some() { return Err(Error::new_spanned( attr, @@ -103,9 +107,9 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu span: kw.span, }); return Ok(()); - } - - let fmt: LitStr = input.parse()?; + } else { + return Err(lookahead.error()); + }; let ahead = input.fork(); ahead.parse::>()?; diff --git a/tests/ui/concat-display.stderr b/tests/ui/concat-display.stderr index dbecd69..d92e635 100644 --- a/tests/ui/concat-display.stderr +++ b/tests/ui/concat-display.stderr @@ -1,4 +1,4 @@ -error: expected string literal +error: expected string literal or `transparent` --> tests/ui/concat-display.rs:8:17 | 8 | #[error(concat!("invalid ", $what))] From 0e2bef9ff16420f81c55a3eacda91a9992a1f526 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 16:42:50 -0700 Subject: [PATCH 009/131] Raise required compiler to rust 1.61 --- .github/workflows/ci.yml | 2 +- Cargo.toml | 2 +- README.md | 2 +- impl/Cargo.toml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 65a20f5..773ca17 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,7 +24,7 @@ jobs: strategy: fail-fast: false matrix: - rust: [nightly, beta, stable, 1.56.0] + rust: [nightly, beta, stable, 1.61.0] timeout-minutes: 45 steps: - uses: actions/checkout@v4 diff --git a/Cargo.toml b/Cargo.toml index 4ed2173..bc50543 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ edition = "2021" keywords = ["error", "error-handling", "derive"] license = "MIT OR Apache-2.0" repository = "https://github.com/dtolnay/thiserror" -rust-version = "1.56" +rust-version = "1.61" [dependencies] thiserror-impl = { version = "=1.0.65", path = "impl" } diff --git a/README.md b/README.md index 3b7d743..54e736d 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ This library provides a convenient derive macro for the standard library's thiserror = "1.0" ``` -*Compiler support: requires rustc 1.56+* +*Compiler support: requires rustc 1.61+*
diff --git a/impl/Cargo.toml b/impl/Cargo.toml index fc0a53b..563271a 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -6,7 +6,7 @@ description = "Implementation detail of the `thiserror` crate" edition = "2021" license = "MIT OR Apache-2.0" repository = "https://github.com/dtolnay/thiserror" -rust-version = "1.56" +rust-version = "1.61" [lib] proc-macro = true From 8fb92ff3f0c93d08fe2a38fc657649ebfc2b5754 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 16:43:53 -0700 Subject: [PATCH 010/131] Resolve uninlined_format_args pedantic clippy lint in build script warning: variables can be used directly in the `format!` string --> build.rs:140:9 | 140 | / eprintln!( 141 | | "Environment variable ${} is not set during execution of build script", 142 | | key, 143 | | ); | |_________^ | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args = note: `-W clippy::uninlined-format-args` implied by `-W clippy::pedantic` = help: to override `-W clippy::pedantic` add `#[allow(clippy::uninlined_format_args)]` --- build.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/build.rs b/build.rs index 51ac436..4b40e9d 100644 --- a/build.rs +++ b/build.rs @@ -137,10 +137,7 @@ fn compile_probe(rustc_bootstrap: bool) -> bool { fn cargo_env_var(key: &str) -> OsString { env::var_os(key).unwrap_or_else(|| { - eprintln!( - "Environment variable ${} is not set during execution of build script", - key, - ); + eprintln!("Environment variable ${key} is not set during execution of build script"); process::exit(1); }) } From 51a5e4cbfedf77915db3e7e23abfd6e5b75d3b05 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 16:48:51 -0700 Subject: [PATCH 011/131] Raise minimum compiler for test suite to rust 1.70 With 1.61: error: package `indexmap v2.6.0` cannot be built because it requires rustc 1.63 or newer, while the currently active rustc version is 1.61.0 With 1.63: error: package `toml_datetime v0.6.8` cannot be built because it requires rustc 1.65 or newer, while the currently active rustc version is 1.63.0 With 1.65: error: package `trybuild v1.0.101` cannot be built because it requires rustc 1.70 or newer, while the currently active rustc version is 1.65.0 Either upgrade to rustc 1.70 or newer, or use cargo update -p trybuild@1.0.101 --precise ver where `ver` is the latest version of `trybuild` supporting rustc 1.65.0 --- .github/workflows/ci.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 773ca17..5dd92eb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,7 +24,7 @@ jobs: strategy: fail-fast: false matrix: - rust: [nightly, beta, stable, 1.61.0] + rust: [nightly, beta, stable, 1.70.0, 1.61.0] timeout-minutes: 45 steps: - uses: actions/checkout@v4 @@ -39,6 +39,7 @@ jobs: run: echo RUSTFLAGS=${RUSTFLAGS}\ --cfg=thiserror_nightly_testing >> $GITHUB_ENV if: matrix.rust == 'nightly' - run: cargo test --all + if: matrix.rust != '1.61.0' - uses: actions/upload-artifact@v4 if: matrix.rust == 'nightly' && always() with: From 3d79a908aca69e2ea80ed51905de8ca9fdf971e5 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 16:38:58 -0700 Subject: [PATCH 012/131] Use peek2(End) instead of fork/advance_to --- impl/Cargo.toml | 2 +- impl/src/attr.rs | 8 +++----- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 563271a..a768f96 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -14,7 +14,7 @@ proc-macro = true [dependencies] proc-macro2 = "1.0.74" quote = "1.0.35" -syn = "2.0.46" +syn = "2.0.86" [package.metadata.docs.rs] targets = ["x86_64-unknown-linux-gnu"] diff --git a/impl/src/attr.rs b/impl/src/attr.rs index e59b519..a3746b0 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -2,7 +2,7 @@ use proc_macro2::{Delimiter, Group, Literal, Punct, Spacing, Span, TokenStream, use quote::{format_ident, quote, ToTokens}; use std::collections::BTreeSet as Set; use syn::parse::discouraged::Speculative; -use syn::parse::ParseStream; +use syn::parse::{End, ParseStream}; use syn::{ braced, bracketed, parenthesized, token, Attribute, Error, Ident, Index, LitFloat, LitInt, LitStr, Meta, Result, Token, @@ -111,10 +111,8 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu return Err(lookahead.error()); }; - let ahead = input.fork(); - ahead.parse::>()?; - let args = if ahead.is_empty() { - input.advance_to(&ahead); + let args = if input.is_empty() || input.peek(Token![,]) && input.peek2(End) { + input.parse::>()?; TokenStream::new() } else { parse_token_expr(input, false)? From d1a8254ee5f7ed833f21972ca0f15a6b266614a5 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 16:54:13 -0700 Subject: [PATCH 013/131] Release 1.0.66 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index bc50543..96a87e8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "1.0.65" +version = "1.0.66" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -12,7 +12,7 @@ repository = "https://github.com/dtolnay/thiserror" rust-version = "1.61" [dependencies] -thiserror-impl = { version = "=1.0.65", path = "impl" } +thiserror-impl = { version = "=1.0.66", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index a768f96..5acbe8f 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "1.0.65" +version = "1.0.66" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 15872e3..b7afdb7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -258,7 +258,7 @@ //! //! [`anyhow`]: https://github.com/dtolnay/anyhow -#![doc(html_root_url = "https://docs.rs/thiserror/1.0.65")] +#![doc(html_root_url = "https://docs.rs/thiserror/1.0.66")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 2b16098823352dee5e91323ec057f0a1853d6851 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 21:02:21 -0700 Subject: [PATCH 014/131] Preserve None-delimited groups inside format args --- impl/src/attr.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/impl/src/attr.rs b/impl/src/attr.rs index a3746b0..c28761c 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -142,6 +142,13 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu fn parse_token_expr(input: ParseStream, mut begin_expr: bool) -> Result { let mut tokens = Vec::new(); while !input.is_empty() { + if input.peek(token::Group) { + let group: TokenTree = input.parse()?; + tokens.push(group); + begin_expr = false; + continue; + } + if begin_expr && input.peek(Token![.]) { if input.peek2(Ident) { input.parse::()?; From 747ce20cc28d62d564ba0a6f0b01e5fef22e93de Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 31 Oct 2024 21:23:45 -0700 Subject: [PATCH 015/131] Remove format var parsing workaround that targeted rustc 1.40 and older --- impl/src/fmt.rs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index b38b7bf..c036536 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -93,11 +93,6 @@ impl Display<'_> { if formatvar.to_string().starts_with("r#") { formatvar = format_ident!("r_{}", formatvar); } - if formatvar.to_string().starts_with('_') { - // Work around leading underscore being rejected by 1.40 and - // older compilers. https://github.com/rust-lang/rust/pull/66847 - formatvar = format_ident!("field_{}", formatvar); - } out += &formatvar.to_string(); if !named_args.insert(formatvar.clone()) { // Already specified in the format argument list. From 751dc63a8ee66102a0b967d189e3d1ab860d29d1 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 09:41:40 -0700 Subject: [PATCH 016/131] Track caller of the assertion helper in test_expr --- tests/test_expr.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_expr.rs b/tests/test_expr.rs index c5e3b4b..e369ba0 100644 --- a/tests/test_expr.rs +++ b/tests/test_expr.rs @@ -50,6 +50,7 @@ pub enum RustupError { }, } +#[track_caller] fn assert(expected: &str, value: T) { assert_eq!(expected, value.to_string()); } From 561e29eb809d78f918b90d624e9617931c4194dd Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 09:39:37 -0700 Subject: [PATCH 017/131] Add regression test for issue 335 error[E0277]: `PathBuf` doesn't implement `std::fmt::Display` --> tests/test_expr.rs:105:14 | 104 | #[derive(Error, Debug)] | ----- in this derive macro expansion 105 | #[error("{A} {b}", b = &0 as &dyn Trait)] | ^^^ `PathBuf` cannot be formatted with the default formatter; call `.display()` on it | = help: the trait `std::fmt::Display` is not implemented for `PathBuf` = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead = note: call `.display()` or `.to_string_lossy()` to safely print paths, as they may contain non-Unicode data = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info) --- tests/test_expr.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/tests/test_expr.rs b/tests/test_expr.rs index e369ba0..4252280 100644 --- a/tests/test_expr.rs +++ b/tests/test_expr.rs @@ -1,6 +1,7 @@ #![allow(clippy::iter_cloned_collect, clippy::uninlined_format_args)] use core::fmt::Display; +use std::path::PathBuf; use thiserror::Error; // Some of the elaborate cases from the rcc codebase, which is a C compiler in @@ -87,3 +88,29 @@ fn test_rustup() { }, ); } + +// Regression test for https://github.com/dtolnay/thiserror/issues/335 +#[test] +#[allow(non_snake_case)] +fn test_assoc_type_equality_constraint() { + pub trait Trait: Display { + type A; + } + + impl Trait for i32 { + type A = i32; + } + + #[derive(Error, Debug)] + #[error("{A} {b}", b = &0 as &dyn Trait)] + pub struct Error { + pub A: PathBuf, + } + + assert( + "... 0", + Error { + A: PathBuf::from("..."), + }, + ); +} From c0050558f7638e1a5c23f2997b5bd6dcaac88a76 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 09:31:56 -0700 Subject: [PATCH 018/131] Import expr scanner from syn 2.0.87 --- impl/Cargo.toml | 2 +- impl/src/lib.rs | 1 + impl/src/scan_expr.rs | 264 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 266 insertions(+), 1 deletion(-) create mode 100644 impl/src/scan_expr.rs diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 5acbe8f..1d65e9c 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -14,7 +14,7 @@ proc-macro = true [dependencies] proc-macro2 = "1.0.74" quote = "1.0.35" -syn = "2.0.86" +syn = "2.0.87" [package.metadata.docs.rs] targets = ["x86_64-unknown-linux-gnu"] diff --git a/impl/src/lib.rs b/impl/src/lib.rs index 58f4bb5..48075eb 100644 --- a/impl/src/lib.rs +++ b/impl/src/lib.rs @@ -23,6 +23,7 @@ mod expand; mod fmt; mod generics; mod prop; +mod scan_expr; mod span; mod valid; diff --git a/impl/src/scan_expr.rs b/impl/src/scan_expr.rs new file mode 100644 index 0000000..155b5b6 --- /dev/null +++ b/impl/src/scan_expr.rs @@ -0,0 +1,264 @@ +use self::{Action::*, Input::*}; +use proc_macro2::{Delimiter, Ident, Spacing, TokenTree}; +use syn::parse::{ParseStream, Result}; +use syn::{AngleBracketedGenericArguments, BinOp, Expr, ExprPath, Lifetime, Lit, Token, Type}; + +enum Input { + Keyword(&'static str), + Punct(&'static str), + ConsumeAny, + ConsumeBinOp, + ConsumeBrace, + ConsumeDelimiter, + ConsumeIdent, + ConsumeLifetime, + ConsumeLiteral, + ConsumeNestedBrace, + ExpectPath, + ExpectTurbofish, + ExpectType, + CanBeginExpr, + Otherwise, + Empty, +} + +enum Action { + SetState(&'static [(Input, Action)]), + IncDepth, + DecDepth, + Finish, +} + +static INIT: [(Input, Action); 28] = [ + (ConsumeDelimiter, SetState(&POSTFIX)), + (Keyword("async"), SetState(&ASYNC)), + (Keyword("break"), SetState(&BREAK_LABEL)), + (Keyword("const"), SetState(&CONST)), + (Keyword("continue"), SetState(&CONTINUE)), + (Keyword("for"), SetState(&FOR)), + (Keyword("if"), IncDepth), + (Keyword("let"), SetState(&PATTERN)), + (Keyword("loop"), SetState(&BLOCK)), + (Keyword("match"), IncDepth), + (Keyword("move"), SetState(&CLOSURE)), + (Keyword("return"), SetState(&RETURN)), + (Keyword("static"), SetState(&CLOSURE)), + (Keyword("unsafe"), SetState(&BLOCK)), + (Keyword("while"), IncDepth), + (Keyword("yield"), SetState(&RETURN)), + (Keyword("_"), SetState(&POSTFIX)), + (Punct("!"), SetState(&INIT)), + (Punct("#"), SetState(&[(ConsumeDelimiter, SetState(&INIT))])), + (Punct("&"), SetState(&REFERENCE)), + (Punct("*"), SetState(&INIT)), + (Punct("-"), SetState(&INIT)), + (Punct("..="), SetState(&INIT)), + (Punct(".."), SetState(&RANGE)), + (Punct("|"), SetState(&CLOSURE_ARGS)), + (ConsumeLifetime, SetState(&[(Punct(":"), SetState(&INIT))])), + (ConsumeLiteral, SetState(&POSTFIX)), + (ExpectPath, SetState(&PATH)), +]; + +static POSTFIX: [(Input, Action); 10] = [ + (Keyword("as"), SetState(&[(ExpectType, SetState(&POSTFIX))])), + (Punct("..="), SetState(&INIT)), + (Punct(".."), SetState(&RANGE)), + (Punct("."), SetState(&DOT)), + (Punct("?"), SetState(&POSTFIX)), + (ConsumeBinOp, SetState(&INIT)), + (Punct("="), SetState(&INIT)), + (ConsumeNestedBrace, SetState(&IF_THEN)), + (ConsumeDelimiter, SetState(&POSTFIX)), + (Empty, Finish), +]; + +static ASYNC: [(Input, Action); 3] = [ + (Keyword("move"), SetState(&ASYNC)), + (Punct("|"), SetState(&CLOSURE_ARGS)), + (ConsumeBrace, SetState(&POSTFIX)), +]; + +static BLOCK: [(Input, Action); 1] = [(ConsumeBrace, SetState(&POSTFIX))]; + +static BREAK_LABEL: [(Input, Action); 2] = [ + (ConsumeLifetime, SetState(&BREAK_VALUE)), + (Otherwise, SetState(&BREAK_VALUE)), +]; + +static BREAK_VALUE: [(Input, Action); 3] = [ + (ConsumeNestedBrace, SetState(&IF_THEN)), + (CanBeginExpr, SetState(&INIT)), + (Otherwise, SetState(&POSTFIX)), +]; + +static CLOSURE: [(Input, Action); 6] = [ + (Keyword("async"), SetState(&CLOSURE)), + (Keyword("move"), SetState(&CLOSURE)), + (Punct(","), SetState(&CLOSURE)), + (Punct(">"), SetState(&CLOSURE)), + (Punct("|"), SetState(&CLOSURE_ARGS)), + (ConsumeLifetime, SetState(&CLOSURE)), +]; + +static CLOSURE_ARGS: [(Input, Action); 2] = [ + (Punct("|"), SetState(&CLOSURE_RET)), + (ConsumeAny, SetState(&CLOSURE_ARGS)), +]; + +static CLOSURE_RET: [(Input, Action); 2] = [ + (Punct("->"), SetState(&[(ExpectType, SetState(&BLOCK))])), + (Otherwise, SetState(&INIT)), +]; + +static CONST: [(Input, Action); 2] = [ + (Punct("|"), SetState(&CLOSURE_ARGS)), + (ConsumeBrace, SetState(&POSTFIX)), +]; + +static CONTINUE: [(Input, Action); 2] = [ + (ConsumeLifetime, SetState(&POSTFIX)), + (Otherwise, SetState(&POSTFIX)), +]; + +static DOT: [(Input, Action); 3] = [ + (Keyword("await"), SetState(&POSTFIX)), + (ConsumeIdent, SetState(&METHOD)), + (ConsumeLiteral, SetState(&POSTFIX)), +]; + +static FOR: [(Input, Action); 2] = [ + (Punct("<"), SetState(&CLOSURE)), + (Otherwise, SetState(&PATTERN)), +]; + +static IF_ELSE: [(Input, Action); 2] = [(Keyword("if"), SetState(&INIT)), (ConsumeBrace, DecDepth)]; +static IF_THEN: [(Input, Action); 2] = + [(Keyword("else"), SetState(&IF_ELSE)), (Otherwise, DecDepth)]; + +static METHOD: [(Input, Action); 1] = [(ExpectTurbofish, SetState(&POSTFIX))]; + +static PATH: [(Input, Action); 4] = [ + (Punct("!="), SetState(&INIT)), + (Punct("!"), SetState(&INIT)), + (ConsumeNestedBrace, SetState(&IF_THEN)), + (Otherwise, SetState(&POSTFIX)), +]; + +static PATTERN: [(Input, Action); 15] = [ + (ConsumeDelimiter, SetState(&PATTERN)), + (Keyword("box"), SetState(&PATTERN)), + (Keyword("in"), IncDepth), + (Keyword("mut"), SetState(&PATTERN)), + (Keyword("ref"), SetState(&PATTERN)), + (Keyword("_"), SetState(&PATTERN)), + (Punct("!"), SetState(&PATTERN)), + (Punct("&"), SetState(&PATTERN)), + (Punct("..="), SetState(&PATTERN)), + (Punct(".."), SetState(&PATTERN)), + (Punct("="), SetState(&INIT)), + (Punct("@"), SetState(&PATTERN)), + (Punct("|"), SetState(&PATTERN)), + (ConsumeLiteral, SetState(&PATTERN)), + (ExpectPath, SetState(&PATTERN)), +]; + +static RANGE: [(Input, Action); 6] = [ + (Punct("..="), SetState(&INIT)), + (Punct(".."), SetState(&RANGE)), + (Punct("."), SetState(&DOT)), + (ConsumeNestedBrace, SetState(&IF_THEN)), + (Empty, Finish), + (Otherwise, SetState(&INIT)), +]; + +static RAW: [(Input, Action); 3] = [ + (Keyword("const"), SetState(&INIT)), + (Keyword("mut"), SetState(&INIT)), + (Otherwise, SetState(&POSTFIX)), +]; + +static REFERENCE: [(Input, Action); 3] = [ + (Keyword("mut"), SetState(&INIT)), + (Keyword("raw"), SetState(&RAW)), + (Otherwise, SetState(&INIT)), +]; + +static RETURN: [(Input, Action); 2] = [ + (CanBeginExpr, SetState(&INIT)), + (Otherwise, SetState(&POSTFIX)), +]; + +pub(crate) fn scan_expr(input: ParseStream) -> Result<()> { + let mut state = INIT.as_slice(); + let mut depth = 0usize; + 'table: loop { + for rule in state { + if match rule.0 { + Input::Keyword(expected) => input.step(|cursor| match cursor.ident() { + Some((ident, rest)) if ident == expected => Ok((true, rest)), + _ => Ok((false, *cursor)), + })?, + Input::Punct(expected) => input.step(|cursor| { + let begin = *cursor; + let mut cursor = begin; + for (i, ch) in expected.chars().enumerate() { + match cursor.punct() { + Some((punct, _)) if punct.as_char() != ch => break, + Some((_, rest)) if i == expected.len() - 1 => { + return Ok((true, rest)); + } + Some((punct, rest)) if punct.spacing() == Spacing::Joint => { + cursor = rest; + } + _ => break, + } + } + Ok((false, begin)) + })?, + Input::ConsumeAny => input.parse::>()?.is_some(), + Input::ConsumeBinOp => input.parse::().is_ok(), + Input::ConsumeBrace | Input::ConsumeNestedBrace => { + (matches!(rule.0, Input::ConsumeBrace) || depth > 0) + && input.step(|cursor| match cursor.group(Delimiter::Brace) { + Some((_inside, _span, rest)) => Ok((true, rest)), + None => Ok((false, *cursor)), + })? + } + Input::ConsumeDelimiter => input.step(|cursor| match cursor.any_group() { + Some((_inside, _delimiter, _span, rest)) => Ok((true, rest)), + None => Ok((false, *cursor)), + })?, + Input::ConsumeIdent => input.parse::>()?.is_some(), + Input::ConsumeLifetime => input.parse::>()?.is_some(), + Input::ConsumeLiteral => input.parse::>()?.is_some(), + Input::ExpectPath => { + input.parse::()?; + true + } + Input::ExpectTurbofish => { + if input.peek(Token![::]) { + input.parse::()?; + } + true + } + Input::ExpectType => { + Type::without_plus(input)?; + true + } + Input::CanBeginExpr => Expr::peek(input), + Input::Otherwise => true, + Input::Empty => input.is_empty() || input.peek(Token![,]), + } { + state = match rule.1 { + Action::SetState(next) => next, + Action::IncDepth => (depth += 1, &INIT).1, + Action::DecDepth => (depth -= 1, &POSTFIX).1, + Action::Finish => return if depth == 0 { Ok(()) } else { break }, + }; + continue 'table; + } + } + return Err(input.error("unsupported expression")); + } +} From 2585669fa1a44c2ce1456e91fdcd38c2f1e747a5 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 09:36:05 -0700 Subject: [PATCH 019/131] More robust scanning for fmt argument expressions --- impl/src/fmt.rs | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index c036536..029870b 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,5 +1,6 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; +use crate::scan_expr::scan_expr; use proc_macro2::TokenTree; use quote::{format_ident, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; @@ -121,14 +122,16 @@ fn explicit_named_args(input: ParseStream) -> Result> { let mut named_args = Set::new(); while !input.is_empty() { - if input.peek(Token![,]) && input.peek2(Ident::peek_any) && input.peek3(Token![=]) { - input.parse::()?; + input.parse::()?; + if input.is_empty() { + break; + } + if input.peek(Ident::peek_any) && input.peek2(Token![=]) && !input.peek2(Token![==]) { let ident = input.call(Ident::parse_any)?; input.parse::()?; named_args.insert(ident); - } else { - input.parse::()?; } + scan_expr(input)?; } Ok(named_args) From 45e18f53dfc8ff742e16bff0b0818b615b317cf0 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 09:45:25 -0700 Subject: [PATCH 020/131] Ignore enum_glob_use pedantic clippy lint warning: usage of wildcard import for enum variants --> impl/src/scan_expr.rs:1:12 | 1 | use self::{Action::*, Input::*}; | ^^^^^^^^^ help: try: `Action::{DecDepth, Finish, IncDepth, SetState}` | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#enum_glob_use = note: `-W clippy::enum-glob-use` implied by `-W clippy::pedantic` = help: to override `-W clippy::pedantic` add `#[allow(clippy::enum_glob_use)]` warning: usage of wildcard import for enum variants --> impl/src/scan_expr.rs:1:23 | 1 | use self::{Action::*, Input::*}; | ^^^^^^^^ help: try: `Input::{CanBeginExpr, ConsumeAny, ConsumeBinOp, ConsumeBrace, ConsumeDelimiter, ConsumeIdent, ConsumeLifetime, ConsumeLiteral, ConsumeNestedBrace, Empty, ExpectPath, ExpectTurbofish, ExpectType, Keyword, Otherwise, Punct}` | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#enum_glob_use --- impl/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/impl/src/lib.rs b/impl/src/lib.rs index 48075eb..7d7c6e3 100644 --- a/impl/src/lib.rs +++ b/impl/src/lib.rs @@ -2,6 +2,7 @@ clippy::blocks_in_conditions, clippy::cast_lossless, clippy::cast_possible_truncation, + clippy::enum_glob_use, clippy::manual_find, clippy::manual_let_else, clippy::manual_map, From 144b3b690b3dcc9338cf5c61dede46c9bbebe4f8 Mon Sep 17 00:00:00 2001 From: Yotam Ofek Date: Fri, 1 Nov 2024 13:47:37 +0000 Subject: [PATCH 021/131] Remove `#[allow]` for fixed clippy bug --- impl/src/generics.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/impl/src/generics.rs b/impl/src/generics.rs index 95592a7..254c2ed 100644 --- a/impl/src/generics.rs +++ b/impl/src/generics.rs @@ -57,7 +57,6 @@ impl InferredBounds { } } - #[allow(clippy::type_repetition_in_bounds, clippy::trait_duplication_in_bounds)] // clippy bug: https://github.com/rust-lang/rust-clippy/issues/8771 pub fn insert(&mut self, ty: impl ToTokens, bound: impl ToTokens) { let ty = ty.to_token_stream(); let bound = bound.to_token_stream(); From dabb96fdaf9a76bf7315bc0a5c8cb0a3974670ad Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 20:41:34 -0700 Subject: [PATCH 022/131] Use syn's real expression parser if it has full syntax support --- impl/src/fmt.rs | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 029870b..df75044 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,12 +1,12 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; -use crate::scan_expr::scan_expr; +use crate::scan_expr; use proc_macro2::TokenTree; -use quote::{format_ident, quote_spanned}; +use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; use syn::ext::IdentExt; use syn::parse::{ParseStream, Parser}; -use syn::{Ident, Index, LitStr, Member, Result, Token}; +use syn::{Expr, Ident, Index, LitStr, Member, Result, Token}; impl Display<'_> { // Transform `"error {var}"` to `"error {}", var`. @@ -119,6 +119,12 @@ impl Display<'_> { } fn explicit_named_args(input: ParseStream) -> Result> { + let scan_expr = if is_syn_full() { + |input: ParseStream| input.parse::().map(drop) + } else { + scan_expr::scan_expr + }; + let mut named_args = Set::new(); while !input.is_empty() { @@ -137,6 +143,24 @@ fn explicit_named_args(input: ParseStream) -> Result> { Ok(named_args) } +fn is_syn_full() -> bool { + // Expr::Block contains syn::Block which contains Vec. In the + // current version of Syn, syn::Stmt is exhaustive and could only plausibly + // represent `trait Trait {}` in Stmt::Item which contains syn::Item. Most + // of the point of syn's non-"full" mode is to avoid compiling Item and the + // entire expansive syntax tree it comprises. So the following expression + // being parsed to Expr::Block is a reliable indication that "full" is + // enabled. + let test = quote!({ + trait Trait {} + }); + match syn::parse2(test) { + Ok(Expr::Verbatim(_)) | Err(_) => false, + Ok(Expr::Block(_)) => true, + Ok(_) => unreachable!(), + } +} + fn take_int(read: &mut &str) -> String { let mut int = String::new(); for (i, ch) in read.char_indices() { From c357f9728e4c5497dec5128d8ed258b82bbd163a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 21:05:30 -0700 Subject: [PATCH 023/131] Add infallible expr scanner fallback for scanning invalid code --- impl/src/fmt.rs | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index df75044..a15aeb6 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,10 +1,11 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; use crate::scan_expr; -use proc_macro2::TokenTree; +use proc_macro2::{TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; use syn::ext::IdentExt; +use syn::parse::discouraged::Speculative; use syn::parse::{ParseStream, Parser}; use syn::{Expr, Ident, Index, LitStr, Member, Result, Token}; @@ -119,6 +120,23 @@ impl Display<'_> { } fn explicit_named_args(input: ParseStream) -> Result> { + let ahead = input.fork(); + if let Ok(set) = try_explicit_named_args(&ahead) { + input.advance_to(&ahead); + return Ok(set); + } + + let ahead = input.fork(); + if let Ok(set) = fallback_explicit_named_args(&ahead) { + input.advance_to(&ahead); + return Ok(set); + } + + input.parse::().unwrap(); + Ok(Set::new()) +} + +fn try_explicit_named_args(input: ParseStream) -> Result> { let scan_expr = if is_syn_full() { |input: ParseStream| input.parse::().map(drop) } else { @@ -143,6 +161,21 @@ fn explicit_named_args(input: ParseStream) -> Result> { Ok(named_args) } +fn fallback_explicit_named_args(input: ParseStream) -> Result> { + let mut named_args = Set::new(); + + while !input.is_empty() { + if input.peek(Token![,]) && input.peek2(Ident::peek_any) && input.peek3(Token![=]) { + input.parse::()?; + let ident = input.call(Ident::parse_any)?; + input.parse::()?; + named_args.insert(ident); + } + } + + Ok(named_args) +} + fn is_syn_full() -> bool { // Expr::Block contains syn::Block which contains Vec. In the // current version of Syn, syn::Stmt is exhaustive and could only plausibly From 0ab908aab0dc12415ce34241fdc23bb722bd0eba Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 2 Nov 2024 21:12:28 -0700 Subject: [PATCH 024/131] Ignore expected unnecessary_wraps pedantic clippy lint warning: this function's return value is unnecessarily wrapped by `Result` --> impl/src/fmt.rs:122:1 | 122 | / fn explicit_named_args(input: ParseStream) -> Result> { 123 | | let ahead = input.fork(); 124 | | if let Ok(set) = try_explicit_named_args(&ahead) { 125 | | input.advance_to(&ahead); ... | 136 | | Ok(Set::new()) 137 | | } | |_^ | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps = note: `-W clippy::unnecessary-wraps` implied by `-W clippy::pedantic` = help: to override `-W clippy::pedantic` add `#[allow(clippy::unnecessary_wraps)]` help: remove `Result` from the return type... | 122 | fn explicit_named_args(input: ParseStream) -> std::collections::BTreeSet { | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ help: ...and then change returning expressions | 126 ~ return set; 127 | } ... 131 | input.advance_to(&ahead); 132 ~ return set; 133 | } 134 | 135 | input.parse::().unwrap(); 136 ~ Set::new() | --- impl/src/fmt.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index a15aeb6..153a423 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -119,6 +119,7 @@ impl Display<'_> { } } +#[allow(clippy::unnecessary_wraps)] fn explicit_named_args(input: ParseStream) -> Result> { let ahead = input.fork(); if let Ok(set) = try_explicit_named_args(&ahead) { From 925f2dde771de0be96f9e6402f8bf5d06f523ebc Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 3 Nov 2024 10:17:51 -0500 Subject: [PATCH 025/131] Release 1.0.67 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 96a87e8..e107eef 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "1.0.66" +version = "1.0.67" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -12,7 +12,7 @@ repository = "https://github.com/dtolnay/thiserror" rust-version = "1.61" [dependencies] -thiserror-impl = { version = "=1.0.66", path = "impl" } +thiserror-impl = { version = "=1.0.67", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 1d65e9c..1b474cb 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "1.0.66" +version = "1.0.67" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index b7afdb7..8437394 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -258,7 +258,7 @@ //! //! [`anyhow`]: https://github.com/dtolnay/anyhow -#![doc(html_root_url = "https://docs.rs/thiserror/1.0.66")] +#![doc(html_root_url = "https://docs.rs/thiserror/1.0.67")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 40a53f7f338e8cca0a3e589d01a19457c4794cc0 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 11:21:12 -0500 Subject: [PATCH 026/131] Interleave Expr parsing and scanning better --- impl/src/fmt.rs | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 153a423..1fc290e 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,6 +1,6 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; -use crate::scan_expr; +use crate::scan_expr::scan_expr; use proc_macro2::{TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; @@ -138,12 +138,7 @@ fn explicit_named_args(input: ParseStream) -> Result> { } fn try_explicit_named_args(input: ParseStream) -> Result> { - let scan_expr = if is_syn_full() { - |input: ParseStream| input.parse::().map(drop) - } else { - scan_expr::scan_expr - }; - + let syn_full = is_syn_full(); let mut named_args = Set::new(); while !input.is_empty() { @@ -156,6 +151,13 @@ fn try_explicit_named_args(input: ParseStream) -> Result> { input.parse::()?; named_args.insert(ident); } + if syn_full { + let ahead = input.fork(); + if ahead.parse::().is_ok() { + input.advance_to(&ahead); + continue; + } + } scan_expr(input)?; } From 7daf1b169d4daed1f2d2765b36726a0ddc29c01c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 11:29:37 -0500 Subject: [PATCH 027/131] Defer is_syn_full() call until first expression --- impl/src/fmt.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 1fc290e..f63fa68 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -138,7 +138,7 @@ fn explicit_named_args(input: ParseStream) -> Result> { } fn try_explicit_named_args(input: ParseStream) -> Result> { - let syn_full = is_syn_full(); + let mut syn_full = None; let mut named_args = Set::new(); while !input.is_empty() { @@ -151,7 +151,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result> { input.parse::()?; named_args.insert(ident); } - if syn_full { + if *syn_full.get_or_insert_with(is_syn_full) { let ahead = input.fork(); if ahead.parse::().is_ok() { input.advance_to(&ahead); From b3bf7a6f69d58c2bfc01a9137fb7b239c88d1ec3 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 11:31:48 -0500 Subject: [PATCH 028/131] Add logic to determine whether unnamed fmt arguments are present --- impl/src/fmt.rs | 38 +++++++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index f63fa68..7d07d55 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -13,7 +13,7 @@ impl Display<'_> { // Transform `"error {var}"` to `"error {}", var`. pub fn expand_shorthand(&mut self, fields: &[Field]) { let raw_args = self.args.clone(); - let mut named_args = explicit_named_args.parse2(raw_args).unwrap(); + let mut named_args = explicit_named_args.parse2(raw_args).unwrap().named; let mut member_index = Map::new(); for (i, field) in fields.iter().enumerate() { member_index.insert(&field.member, i); @@ -119,8 +119,13 @@ impl Display<'_> { } } +struct FmtArguments { + named: Set, + unnamed: bool, +} + #[allow(clippy::unnecessary_wraps)] -fn explicit_named_args(input: ParseStream) -> Result> { +fn explicit_named_args(input: ParseStream) -> Result { let ahead = input.fork(); if let Ok(set) = try_explicit_named_args(&ahead) { input.advance_to(&ahead); @@ -134,12 +139,18 @@ fn explicit_named_args(input: ParseStream) -> Result> { } input.parse::().unwrap(); - Ok(Set::new()) + Ok(FmtArguments { + named: Set::new(), + unnamed: false, + }) } -fn try_explicit_named_args(input: ParseStream) -> Result> { +fn try_explicit_named_args(input: ParseStream) -> Result { let mut syn_full = None; - let mut named_args = Set::new(); + let mut args = FmtArguments { + named: Set::new(), + unnamed: false, + }; while !input.is_empty() { input.parse::()?; @@ -149,7 +160,9 @@ fn try_explicit_named_args(input: ParseStream) -> Result> { if input.peek(Ident::peek_any) && input.peek2(Token![=]) && !input.peek2(Token![==]) { let ident = input.call(Ident::parse_any)?; input.parse::()?; - named_args.insert(ident); + args.named.insert(ident); + } else { + args.unnamed = true; } if *syn_full.get_or_insert_with(is_syn_full) { let ahead = input.fork(); @@ -161,22 +174,25 @@ fn try_explicit_named_args(input: ParseStream) -> Result> { scan_expr(input)?; } - Ok(named_args) + Ok(args) } -fn fallback_explicit_named_args(input: ParseStream) -> Result> { - let mut named_args = Set::new(); +fn fallback_explicit_named_args(input: ParseStream) -> Result { + let mut args = FmtArguments { + named: Set::new(), + unnamed: false, + }; while !input.is_empty() { if input.peek(Token![,]) && input.peek2(Ident::peek_any) && input.peek3(Token![=]) { input.parse::()?; let ident = input.call(Ident::parse_any)?; input.parse::()?; - named_args.insert(ident); + args.named.insert(ident); } } - Ok(named_args) + Ok(args) } fn is_syn_full() -> bool { From 08f89925bf0df7a3fe758129e4dbea1097c48bce Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 11:45:52 -0500 Subject: [PATCH 029/131] Disregard equality binop in fallback parser --- impl/src/fmt.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 7d07d55..3d1394c 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -184,7 +184,11 @@ fn fallback_explicit_named_args(input: ParseStream) -> Result { }; while !input.is_empty() { - if input.peek(Token![,]) && input.peek2(Ident::peek_any) && input.peek3(Token![=]) { + if input.peek(Token![,]) + && input.peek2(Ident::peek_any) + && input.peek3(Token![=]) + && !input.peek3(Token![==]) + { input.parse::()?; let ident = input.call(Ident::parse_any)?; input.parse::()?; From 8d06fb554905b054d44a353bea9c92d0bbeb0bdf Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 11:49:43 -0500 Subject: [PATCH 030/131] Release 1.0.68 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index e107eef..23f3609 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "1.0.67" +version = "1.0.68" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -12,7 +12,7 @@ repository = "https://github.com/dtolnay/thiserror" rust-version = "1.61" [dependencies] -thiserror-impl = { version = "=1.0.67", path = "impl" } +thiserror-impl = { version = "=1.0.68", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 1b474cb..933831e 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "1.0.67" +version = "1.0.68" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 8437394..30715fe 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -258,7 +258,7 @@ //! //! [`anyhow`]: https://github.com/dtolnay/anyhow -#![doc(html_root_url = "https://docs.rs/thiserror/1.0.67")] +#![doc(html_root_url = "https://docs.rs/thiserror/1.0.68")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 6b48b090f8fac94927d0a6d08c0fb0efef979e66 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 15:14:31 -0500 Subject: [PATCH 031/131] Add test of non-rawable keyword in format string --- tests/test_display.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/tests/test_display.rs b/tests/test_display.rs index 89bdc4a..7fad386 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -318,6 +318,15 @@ fn test_keyword() { assert("error: 1", Error); } +#[test] +fn test_self() { + #[derive(Error, Debug)] + #[error("error: {self:?}")] + struct Error; + + assert("error: Error", Error); +} + #[test] fn test_str_special_chars() { #[derive(Error, Debug)] From 4d397bc1864e44f3cfdd788c3ef4c1b3e3ef06c0 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 15:15:44 -0500 Subject: [PATCH 032/131] Add test of underscore variable in format string --- tests/ui/display-underscore.rs | 7 +++++++ tests/ui/display-underscore.stderr | 7 +++++++ 2 files changed, 14 insertions(+) create mode 100644 tests/ui/display-underscore.rs create mode 100644 tests/ui/display-underscore.stderr diff --git a/tests/ui/display-underscore.rs b/tests/ui/display-underscore.rs new file mode 100644 index 0000000..335614b --- /dev/null +++ b/tests/ui/display-underscore.rs @@ -0,0 +1,7 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("{_}")] +pub struct Error; + +fn main() {} diff --git a/tests/ui/display-underscore.stderr b/tests/ui/display-underscore.stderr new file mode 100644 index 0000000..36882b9 --- /dev/null +++ b/tests/ui/display-underscore.stderr @@ -0,0 +1,7 @@ +error: invalid format string: invalid argument name `_` + --> tests/ui/display-underscore.rs:4:11 + | +4 | #[error("{_}")] + | ^ invalid argument name in format string + | + = note: argument name cannot be a single underscore From ef59afe2d4437e0c24421f501fafe88cf3ca5740 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 15:10:00 -0500 Subject: [PATCH 033/131] Delete support for raw identifiers inside format string --- impl/src/fmt.rs | 28 ++++++++++++++++------------ tests/test_display.rs | 15 ++------------- 2 files changed, 18 insertions(+), 25 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 3d1394c..5d026d1 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,7 +1,7 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; -use proc_macro2::{TokenStream, TokenTree}; +use proc_macro2::{Span, TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; use syn::ext::IdentExt; @@ -87,14 +87,10 @@ impl Display<'_> { }; implied_bounds.insert((field, bound)); } - let local = match &member { + let formatvar = match &member { Member::Unnamed(index) => format_ident!("_{}", index), Member::Named(ident) => ident.clone(), }; - let mut formatvar = local.clone(); - if formatvar.to_string().starts_with("r#") { - formatvar = format_ident!("r_{}", formatvar); - } out += &formatvar.to_string(); if !named_args.insert(formatvar.clone()) { // Already specified in the format argument list. @@ -103,6 +99,7 @@ impl Display<'_> { if !has_trailing_comma { args.extend(quote_spanned!(span=> ,)); } + let local = raw_if_needed(&formatvar); args.extend(quote_spanned!(span=> #formatvar = #local)); if read.starts_with('}') && member_index.contains_key(&member) { has_bonus_display = true; @@ -233,11 +230,6 @@ fn take_int(read: &mut &str) -> String { fn take_ident(read: &mut &str) -> Ident { let mut ident = String::new(); - let raw = read.starts_with("r#"); - if raw { - ident.push_str("r#"); - *read = &read[2..]; - } for (i, ch) in read.char_indices() { match ch { 'a'..='z' | 'A'..='Z' | '0'..='9' | '_' => ident.push(ch), @@ -247,5 +239,17 @@ fn take_ident(read: &mut &str) -> Ident { } } } - Ident::parse_any.parse_str(&ident).unwrap() + Ident::new(&ident, Span::call_site()) +} + +fn raw_if_needed(ident: &Ident) -> Ident { + let repr = ident.to_string(); + if syn::parse_str::(&repr).is_err() { + if let "_" | "super" | "self" | "Self" | "crate" = repr.as_str() { + // Some identifiers are never allowed to appear as raw, like r#self and r#_. + } else { + return Ident::new_raw(&repr, Span::call_site()); + } + } + ident.clone() } diff --git a/tests/test_display.rs b/tests/test_display.rs index 7fad386..27bb72c 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -279,7 +279,7 @@ fn test_macro_rules() { #[test] fn test_raw() { #[derive(Error, Debug)] - #[error("braced raw error: {r#fn}")] + #[error("braced raw error: {fn}")] struct Error { r#fn: &'static str, } @@ -291,24 +291,13 @@ fn test_raw() { fn test_raw_enum() { #[derive(Error, Debug)] enum Error { - #[error("braced raw error: {r#fn}")] + #[error("braced raw error: {fn}")] Braced { r#fn: &'static str }, } assert("braced raw error: T", Error::Braced { r#fn: "T" }); } -#[test] -fn test_raw_conflict() { - #[derive(Error, Debug)] - enum Error { - #[error("braced raw error: {r#func}, {func}", func = "U")] - Braced { r#func: &'static str }, - } - - assert("braced raw error: T, U", Error::Braced { r#func: "T" }); -} - #[test] fn test_keyword() { #[derive(Error, Debug)] From 11428341395052b8201683cc12763c10fccc6761 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 15:22:02 -0500 Subject: [PATCH 034/131] Add ui test of raw identifier in format string --- tests/ui/raw-identifier.rs | 12 ++++++++++++ tests/ui/raw-identifier.stderr | 21 +++++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 tests/ui/raw-identifier.rs create mode 100644 tests/ui/raw-identifier.stderr diff --git a/tests/ui/raw-identifier.rs b/tests/ui/raw-identifier.rs new file mode 100644 index 0000000..e7e66d0 --- /dev/null +++ b/tests/ui/raw-identifier.rs @@ -0,0 +1,12 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("error: {r#fn}")] +pub struct Error { + r#fn: &'static str, +} + +fn main() { + let r#fn = "..."; + let _ = format!("error: {r#fn}"); +} diff --git a/tests/ui/raw-identifier.stderr b/tests/ui/raw-identifier.stderr new file mode 100644 index 0000000..a3ce94d --- /dev/null +++ b/tests/ui/raw-identifier.stderr @@ -0,0 +1,21 @@ +error: invalid format string: raw identifiers are not supported + --> tests/ui/raw-identifier.rs:4:18 + | +4 | #[error("error: {r#fn}")] + | --^^ + | | + | raw identifier used here in format string + | help: remove the `r#` + | + = note: identifiers in format strings can be keywords and don't need to be prefixed with `r#` + +error: invalid format string: raw identifiers are not supported + --> tests/ui/raw-identifier.rs:11:30 + | +11 | let _ = format!("error: {r#fn}"); + | --^^ + | | + | raw identifier used here in format string + | help: remove the `r#` + | + = note: identifiers in format strings can be keywords and don't need to be prefixed with `r#` From 3814afebf4a80b85fbd09203371a199b879e76d0 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 15:25:27 -0500 Subject: [PATCH 035/131] Stick to only string manipulation in take_ident --- impl/src/fmt.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 5d026d1..4561e9f 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -63,8 +63,7 @@ impl Display<'_> { member } 'a'..='z' | 'A'..='Z' | '_' => { - let mut ident = take_ident(&mut read); - ident.set_span(span); + let ident = Ident::new(&take_ident(&mut read), span); Member::Named(ident) } _ => continue, @@ -228,7 +227,7 @@ fn take_int(read: &mut &str) -> String { int } -fn take_ident(read: &mut &str) -> Ident { +fn take_ident(read: &mut &str) -> String { let mut ident = String::new(); for (i, ch) in read.char_indices() { match ch { @@ -239,7 +238,7 @@ fn take_ident(read: &mut &str) -> Ident { } } } - Ident::new(&ident, Span::call_site()) + ident } fn raw_if_needed(ident: &Ident) -> Ident { From 6ddeda270efe31eaf040af433539e5505c0ab12b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 14:55:33 -0500 Subject: [PATCH 036/131] Fix edge case of take_int and take_ident at end of string --- impl/src/fmt.rs | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 4561e9f..811f970 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -57,13 +57,13 @@ impl Display<'_> { Err(_) => return, }; if !member_index.contains_key(&member) { - out += ∫ + out += int; continue; } member } 'a'..='z' | 'A'..='Z' | '_' => { - let ident = Ident::new(&take_ident(&mut read), span); + let ident = Ident::new(take_ident(&mut read), span); Member::Named(ident) } _ => continue, @@ -213,31 +213,29 @@ fn is_syn_full() -> bool { } } -fn take_int(read: &mut &str) -> String { - let mut int = String::new(); - for (i, ch) in read.char_indices() { +fn take_int<'a>(read: &mut &'a str) -> &'a str { + let mut int_len = 0; + for ch in read.chars() { match ch { - '0'..='9' => int.push(ch), - _ => { - *read = &read[i..]; - break; - } + '0'..='9' => int_len += 1, + _ => break, } } + let (int, rest) = read.split_at(int_len); + *read = rest; int } -fn take_ident(read: &mut &str) -> String { - let mut ident = String::new(); - for (i, ch) in read.char_indices() { +fn take_ident<'a>(read: &mut &'a str) -> &'a str { + let mut ident_len = 0; + for ch in read.chars() { match ch { - 'a'..='z' | 'A'..='Z' | '0'..='9' | '_' => ident.push(ch), - _ => { - *read = &read[i..]; - break; - } + 'a'..='z' | 'A'..='Z' | '0'..='9' | '_' => ident_len += 1, + _ => break, } } + let (ident, rest) = read.split_at(ident_len); + *read = rest; ident } From 78d6bd6fcaa440eb339c924f98dc35d17861cf64 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 15:47:42 -0500 Subject: [PATCH 037/131] Add a type for representing raw-agnostic format vars --- impl/src/fmt.rs | 27 ++++++------------- impl/src/lib.rs | 1 + impl/src/unraw.rs | 67 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 76 insertions(+), 19 deletions(-) create mode 100644 impl/src/unraw.rs diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 811f970..aa69986 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,7 +1,8 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; -use proc_macro2::{Span, TokenStream, TokenTree}; +use crate::unraw::IdentUnraw; +use proc_macro2::{TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; use syn::ext::IdentExt; @@ -86,10 +87,10 @@ impl Display<'_> { }; implied_bounds.insert((field, bound)); } - let formatvar = match &member { + let formatvar = IdentUnraw::new(match &member { Member::Unnamed(index) => format_ident!("_{}", index), Member::Named(ident) => ident.clone(), - }; + }); out += &formatvar.to_string(); if !named_args.insert(formatvar.clone()) { // Already specified in the format argument list. @@ -98,7 +99,7 @@ impl Display<'_> { if !has_trailing_comma { args.extend(quote_spanned!(span=> ,)); } - let local = raw_if_needed(&formatvar); + let local = formatvar.to_local(); args.extend(quote_spanned!(span=> #formatvar = #local)); if read.starts_with('}') && member_index.contains_key(&member) { has_bonus_display = true; @@ -116,7 +117,7 @@ impl Display<'_> { } struct FmtArguments { - named: Set, + named: Set, unnamed: bool, } @@ -154,7 +155,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result { break; } if input.peek(Ident::peek_any) && input.peek2(Token![=]) && !input.peek2(Token![==]) { - let ident = input.call(Ident::parse_any)?; + let ident: IdentUnraw = input.parse()?; input.parse::()?; args.named.insert(ident); } else { @@ -186,7 +187,7 @@ fn fallback_explicit_named_args(input: ParseStream) -> Result { && !input.peek3(Token![==]) { input.parse::()?; - let ident = input.call(Ident::parse_any)?; + let ident: IdentUnraw = input.parse()?; input.parse::()?; args.named.insert(ident); } @@ -238,15 +239,3 @@ fn take_ident<'a>(read: &mut &'a str) -> &'a str { *read = rest; ident } - -fn raw_if_needed(ident: &Ident) -> Ident { - let repr = ident.to_string(); - if syn::parse_str::(&repr).is_err() { - if let "_" | "super" | "self" | "Self" | "crate" = repr.as_str() { - // Some identifiers are never allowed to appear as raw, like r#self and r#_. - } else { - return Ident::new_raw(&repr, Span::call_site()); - } - } - ident.clone() -} diff --git a/impl/src/lib.rs b/impl/src/lib.rs index 7d7c6e3..a86242d 100644 --- a/impl/src/lib.rs +++ b/impl/src/lib.rs @@ -26,6 +26,7 @@ mod generics; mod prop; mod scan_expr; mod span; +mod unraw; mod valid; use proc_macro::TokenStream; diff --git a/impl/src/unraw.rs b/impl/src/unraw.rs new file mode 100644 index 0000000..1fcaf6c --- /dev/null +++ b/impl/src/unraw.rs @@ -0,0 +1,67 @@ +use proc_macro2::{Ident, Span, TokenStream}; +use quote::ToTokens; +use std::cmp::Ordering; +use std::fmt::{self, Display}; +use syn::ext::IdentExt as _; +use syn::parse::{Parse, ParseStream, Result}; + +#[derive(Clone)] +#[repr(transparent)] +pub(crate) struct IdentUnraw(Ident); + +impl IdentUnraw { + pub fn new(ident: Ident) -> Self { + IdentUnraw(ident) + } + + pub fn to_local(&self) -> Ident { + let unraw = self.0.unraw(); + let repr = unraw.to_string(); + if syn::parse_str::(&repr).is_err() { + if let "_" | "super" | "self" | "Self" | "crate" = repr.as_str() { + // Some identifiers are never allowed to appear as raw, like r#self and r#_. + } else { + return Ident::new_raw(&repr, Span::call_site()); + } + } + unraw + } +} + +impl Display for IdentUnraw { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + Display::fmt(&self.0.unraw(), formatter) + } +} + +impl Eq for IdentUnraw {} + +impl PartialEq for IdentUnraw { + fn eq(&self, other: &Self) -> bool { + PartialEq::eq(&self.0.unraw(), &other.0.unraw()) + } +} + +impl Ord for IdentUnraw { + fn cmp(&self, other: &Self) -> Ordering { + Ord::cmp(&self.0.unraw(), &other.0.unraw()) + } +} + +impl PartialOrd for IdentUnraw { + fn partial_cmp(&self, other: &Self) -> Option { + Some(Self::cmp(self, other)) + } +} + +impl Parse for IdentUnraw { + fn parse(input: ParseStream) -> Result { + input.call(Ident::parse_any).map(IdentUnraw::new) + } +} + +impl ToTokens for IdentUnraw { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.0.unraw().to_tokens(tokens); + } +} From b2df5d55ec626bc02b1c4706608bbadaa530e283 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 16:29:55 -0500 Subject: [PATCH 038/131] Add test of r#source that is not Error::source Without r#source: error[E0599]: the method `as_dyn_error` exists for type `char`, but its trait bounds were not satisfied --> tests/test_source.rs:72:9 | 72 | source: char, | ^^^^^^ method cannot be called on `char` due to unsatisfied trait bounds | = note: the following trait bounds were not satisfied: `char: std::error::Error` which is required by `char: AsDynError<'_>` --- tests/test_source.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tests/test_source.rs b/tests/test_source.rs index 637f4ac..29968be 100644 --- a/tests/test_source.rs +++ b/tests/test_source.rs @@ -63,3 +63,20 @@ error_from_macro! { #[error("Something")] Variant(#[from] io::Error) } + +#[test] +fn test_not_source() { + #[derive(Error, Debug)] + #[error("{source} ==> {destination}")] + pub struct NotSource { + r#source: char, + destination: char, + } + + let error = NotSource { + source: 'S', + destination: 'D', + }; + assert_eq!(error.to_string(), "S ==> D"); + assert!(error.source().is_none()); +} From 9709257b594e24c6fd3ba4533f9c6be26de01085 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 16:33:32 -0500 Subject: [PATCH 039/131] Add test of r#Backtrace that is not std::backtrace::Backtrace Without r#Backtrace: error[E0308]: mismatched types --> tests/test_backtrace.rs:42:14 | 42 | #[derive(Error, Debug)] | ^^^^^ | | | expected `std::backtrace::Backtrace`, found `not_backtrace::Backtrace` | arguments to this method are incorrect | = note: `not_backtrace::Backtrace` and `std::backtrace::Backtrace` have similar names, but are actually distinct types note: `not_backtrace::Backtrace` is defined in the current crate --> tests/test_backtrace.rs:26:9 | 26 | pub struct Backtrace; | ^^^^^^^^^^^^^^^^^^^^ note: `std::backtrace::Backtrace` is defined in crate `std` --> $RUSTUP_HOME/toolchains/nightly-aarch64-unknown-linux-gnu/lib/rustlib/src/rust/library/std/src/backtrace.rs:108:1 | 108 | pub struct Backtrace { | ^^^^^^^^^^^^^^^^^^^^ note: method defined here --> $RUSTUP_HOME/toolchains/nightly-aarch64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/error.rs:607:12 | 607 | pub fn provide_ref(&mut self, value: &'a T) -> &mut Self { | ^^^^^^^^^^^ = note: this error originates in the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info) --- tests/test_backtrace.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/tests/test_backtrace.rs b/tests/test_backtrace.rs index 8f11da3..2a4cffa 100644 --- a/tests/test_backtrace.rs +++ b/tests/test_backtrace.rs @@ -21,6 +21,11 @@ pub mod structs { use std::sync::Arc; use thiserror::Error; + mod not_backtrace { + #[derive(Debug)] + pub struct Backtrace; + } + #[derive(Error, Debug)] #[error("...")] pub struct PlainBacktrace { @@ -34,6 +39,12 @@ pub mod structs { backtrace: Backtrace, } + #[derive(Error, Debug)] + #[error("...")] + pub struct NotBacktrace { + backtrace: crate::structs::not_backtrace::r#Backtrace, + } + #[derive(Error, Debug)] #[error("...")] pub struct OptBacktrace { From 9116fdb8eae27ec0e29084c8eb55e510cf29741b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 16:15:35 -0500 Subject: [PATCH 040/131] Use IdentUnraw consistently when comparing Member --- impl/src/ast.rs | 15 +++++++------ impl/src/expand.rs | 16 +++++++------- impl/src/fmt.rs | 16 +++++++------- impl/src/lib.rs | 1 - impl/src/prop.rs | 6 +++--- impl/src/span.rs | 15 ------------- impl/src/unraw.rs | 54 +++++++++++++++++++++++++++++++++++++++++++++- impl/src/valid.rs | 7 +++--- 8 files changed, 84 insertions(+), 46 deletions(-) delete mode 100644 impl/src/span.rs diff --git a/impl/src/ast.rs b/impl/src/ast.rs index 4739d58..0f9fbeb 100644 --- a/impl/src/ast.rs +++ b/impl/src/ast.rs @@ -1,9 +1,9 @@ use crate::attr::{self, Attrs}; use crate::generics::ParamsInScope; +use crate::unraw::{IdentUnraw, MemberUnraw}; use proc_macro2::Span; 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> { @@ -35,7 +35,7 @@ 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, } @@ -136,12 +136,13 @@ impl<'a> Field<'a> { 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, - }) - }), + }), + }, ty: &node.ty, contains_generic: scope.intersects(&node.ty), }) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 403cd07..3baea02 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -1,11 +1,11 @@ use crate::ast::{Enum, Field, Input, Struct}; use crate::attr::Trait; use crate::generics::InferredBounds; -use crate::span::MemberSpan; +use crate::unraw::MemberUnraw; use proc_macro2::TokenStream; use quote::{format_ident, quote, quote_spanned, ToTokens}; use std::collections::BTreeSet as Set; -use syn::{DeriveInput, GenericArgument, Member, PathArguments, Result, Token, Type}; +use syn::{DeriveInput, GenericArgument, PathArguments, Result, Token, Type}; pub fn derive(input: &DeriveInput) -> TokenStream { match try_expand(input) { @@ -409,8 +409,8 @@ fn impl_enum(input: Enum) -> TokenStream { } None => { let only_field = match &variant.fields[0].member { - Member::Named(ident) => ident.clone(), - Member::Unnamed(index) => format_ident!("_{}", index), + MemberUnraw::Named(ident) => ident.to_local(), + MemberUnraw::Unnamed(index) => format_ident!("_{}", index), }; display_implied_bounds.insert((0, Trait::Display)); quote!(::core::fmt::Display::fmt(#only_field, __formatter)) @@ -487,11 +487,11 @@ fn impl_enum(input: Enum) -> TokenStream { fn fields_pat(fields: &[Field]) -> TokenStream { let mut members = fields.iter().map(|field| &field.member).peekable(); match members.peek() { - Some(Member::Named(_)) => quote!({ #(#members),* }), - Some(Member::Unnamed(_)) => { + Some(MemberUnraw::Named(_)) => quote!({ #(#members),* }), + Some(MemberUnraw::Unnamed(_)) => { let vars = members.map(|member| match member { - Member::Unnamed(member) => format_ident!("_{}", member), - Member::Named(_) => unreachable!(), + MemberUnraw::Unnamed(member) => format_ident!("_{}", member), + MemberUnraw::Named(_) => unreachable!(), }); quote!((#(#vars),*)) } diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index aa69986..8b571d9 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,14 +1,14 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; -use crate::unraw::IdentUnraw; +use crate::unraw::{IdentUnraw, MemberUnraw}; use proc_macro2::{TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; use syn::ext::IdentExt; use syn::parse::discouraged::Speculative; use syn::parse::{ParseStream, Parser}; -use syn::{Expr, Ident, Index, LitStr, Member, Result, Token}; +use syn::{Expr, Ident, Index, LitStr, Result, Token}; impl Display<'_> { // Transform `"error {var}"` to `"error {}", var`. @@ -54,7 +54,7 @@ impl Display<'_> { '0'..='9' => { let int = take_int(&mut read); let member = match int.parse::() { - Ok(index) => Member::Unnamed(Index { index, span }), + Ok(index) => MemberUnraw::Unnamed(Index { index, span }), Err(_) => return, }; if !member_index.contains_key(&member) { @@ -65,7 +65,7 @@ impl Display<'_> { } 'a'..='z' | 'A'..='Z' | '_' => { let ident = Ident::new(take_ident(&mut read), span); - Member::Named(ident) + MemberUnraw::Named(IdentUnraw::new(ident)) } _ => continue, }; @@ -87,10 +87,10 @@ impl Display<'_> { }; implied_bounds.insert((field, bound)); } - let formatvar = IdentUnraw::new(match &member { - Member::Unnamed(index) => format_ident!("_{}", index), - Member::Named(ident) => ident.clone(), - }); + let formatvar = match &member { + MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("_{}", index)), + MemberUnraw::Named(ident) => ident.clone(), + }; out += &formatvar.to_string(); if !named_args.insert(formatvar.clone()) { // Already specified in the format argument list. diff --git a/impl/src/lib.rs b/impl/src/lib.rs index a86242d..5148323 100644 --- a/impl/src/lib.rs +++ b/impl/src/lib.rs @@ -25,7 +25,6 @@ mod fmt; mod generics; mod prop; mod scan_expr; -mod span; mod unraw; mod valid; diff --git a/impl/src/prop.rs b/impl/src/prop.rs index 2867cd3..f3026a4 100644 --- a/impl/src/prop.rs +++ b/impl/src/prop.rs @@ -1,7 +1,7 @@ use crate::ast::{Enum, Field, Struct, Variant}; -use crate::span::MemberSpan; +use crate::unraw::MemberUnraw; use proc_macro2::Span; -use syn::{Member, Type}; +use syn::Type; impl Struct<'_> { pub(crate) fn from_field(&self) -> Option<&Field> { @@ -101,7 +101,7 @@ fn source_field<'a, 'b>(fields: &'a [Field<'b>]) -> Option<&'a Field<'b>> { } for field in fields { match &field.member { - Member::Named(ident) if ident == "source" => return Some(field), + MemberUnraw::Named(ident) if ident == "source" => return Some(field), _ => {} } } diff --git a/impl/src/span.rs b/impl/src/span.rs deleted file mode 100644 index c1237dd..0000000 --- a/impl/src/span.rs +++ /dev/null @@ -1,15 +0,0 @@ -use proc_macro2::Span; -use syn::Member; - -pub trait MemberSpan { - fn member_span(&self) -> Span; -} - -impl MemberSpan for Member { - fn member_span(&self) -> Span { - match self { - Member::Named(ident) => ident.span(), - Member::Unnamed(index) => index.span, - } - } -} diff --git a/impl/src/unraw.rs b/impl/src/unraw.rs index 1fcaf6c..7bdebef 100644 --- a/impl/src/unraw.rs +++ b/impl/src/unraw.rs @@ -2,12 +2,14 @@ use proc_macro2::{Ident, Span, TokenStream}; use quote::ToTokens; use std::cmp::Ordering; use std::fmt::{self, Display}; +use std::hash::{Hash, Hasher}; use syn::ext::IdentExt as _; use syn::parse::{Parse, ParseStream, Result}; +use syn::Index; #[derive(Clone)] #[repr(transparent)] -pub(crate) struct IdentUnraw(Ident); +pub struct IdentUnraw(Ident); impl IdentUnraw { pub fn new(ident: Ident) -> Self { @@ -42,6 +44,12 @@ impl PartialEq for IdentUnraw { } } +impl PartialEq for IdentUnraw { + fn eq(&self, other: &str) -> bool { + self.0 == other + } +} + impl Ord for IdentUnraw { fn cmp(&self, other: &Self) -> Ordering { Ord::cmp(&self.0.unraw(), &other.0.unraw()) @@ -65,3 +73,47 @@ impl ToTokens for IdentUnraw { self.0.unraw().to_tokens(tokens); } } + +pub enum MemberUnraw { + Named(IdentUnraw), + Unnamed(Index), +} + +impl MemberUnraw { + pub fn member_span(&self) -> Span { + match self { + MemberUnraw::Named(ident) => ident.0.span(), + MemberUnraw::Unnamed(index) => index.span, + } + } +} + +impl Eq for MemberUnraw {} + +impl PartialEq for MemberUnraw { + fn eq(&self, other: &Self) -> bool { + match (self, other) { + (MemberUnraw::Named(this), MemberUnraw::Named(other)) => this == other, + (MemberUnraw::Unnamed(this), MemberUnraw::Unnamed(other)) => this == other, + _ => false, + } + } +} + +impl Hash for MemberUnraw { + fn hash(&self, hasher: &mut H) { + match self { + MemberUnraw::Named(ident) => ident.0.unraw().hash(hasher), + MemberUnraw::Unnamed(index) => index.hash(hasher), + } + } +} + +impl ToTokens for MemberUnraw { + fn to_tokens(&self, tokens: &mut TokenStream) { + match self { + MemberUnraw::Named(ident) => ident.to_local().to_tokens(tokens), + MemberUnraw::Unnamed(index) => index.to_tokens(tokens), + } + } +} diff --git a/impl/src/valid.rs b/impl/src/valid.rs index cf5b859..3b475af 100644 --- a/impl/src/valid.rs +++ b/impl/src/valid.rs @@ -1,8 +1,9 @@ use crate::ast::{Enum, Field, Input, Struct, Variant}; use crate::attr::Attrs; +use crate::unraw::MemberUnraw; use quote::ToTokens; use std::collections::BTreeSet as Set; -use syn::{Error, GenericArgument, Member, PathArguments, Result, Type}; +use syn::{Error, GenericArgument, PathArguments, Result, Type}; impl Input<'_> { pub(crate) fn validate(&self) -> Result<()> { @@ -204,8 +205,8 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> { fn same_member(one: &Field, two: &Field) -> bool { match (&one.member, &two.member) { - (Member::Named(one), Member::Named(two)) => one == two, - (Member::Unnamed(one), Member::Unnamed(two)) => one.index == two.index, + (MemberUnraw::Named(one), MemberUnraw::Named(two)) => one == two, + (MemberUnraw::Unnamed(one), MemberUnraw::Unnamed(two)) => one.index == two.index, _ => unreachable!(), } } From e015360076d996b6900a3bc87cb68517c4e87a91 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 17:11:43 -0500 Subject: [PATCH 041/131] Rename MemberUnraw::member_span() to just span() --- impl/src/expand.rs | 16 ++++++++-------- impl/src/prop.rs | 2 +- impl/src/unraw.rs | 2 +- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 3baea02..77f7157 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -75,7 +75,7 @@ fn impl_struct(input: Struct) -> TokenStream { error_inferred_bounds.insert(ty, quote!(std::error::Error + 'static)); } let asref = if type_is_option(source_field.ty) { - Some(quote_spanned!(source.member_span()=> .as_ref()?)) + Some(quote_spanned!(source.span()=> .as_ref()?)) } else { None }; @@ -103,13 +103,13 @@ fn impl_struct(input: Struct) -> TokenStream { let body = if let Some(source_field) = input.source_field() { let source = &source_field.member; let source_provide = if type_is_option(source_field.ty) { - quote_spanned! {source.member_span()=> + quote_spanned! {source.span()=> if let ::core::option::Option::Some(source) = &self.#source { source.thiserror_provide(#request); } } } else { - quote_spanned! {source.member_span()=> + quote_spanned! {source.span()=> self.#source.thiserror_provide(#request); } }; @@ -252,7 +252,7 @@ fn impl_enum(input: Enum) -> TokenStream { error_inferred_bounds.insert(ty, quote!(std::error::Error + 'static)); } let asref = if type_is_option(source_field.ty) { - Some(quote_spanned!(source.member_span()=> .as_ref()?)) + Some(quote_spanned!(source.span()=> .as_ref()?)) } else { None }; @@ -294,13 +294,13 @@ fn impl_enum(input: Enum) -> TokenStream { let source = &source_field.member; let varsource = quote!(source); let source_provide = if type_is_option(source_field.ty) { - quote_spanned! {source.member_span()=> + quote_spanned! {source.span()=> if let ::core::option::Option::Some(source) = #varsource { source.thiserror_provide(#request); } } } else { - quote_spanned! {source.member_span()=> + quote_spanned! {source.span()=> #varsource.thiserror_provide(#request); } }; @@ -333,13 +333,13 @@ fn impl_enum(input: Enum) -> TokenStream { let backtrace = &backtrace_field.member; let varsource = quote!(source); let source_provide = if type_is_option(source_field.ty) { - quote_spanned! {backtrace.member_span()=> + quote_spanned! {backtrace.span()=> if let ::core::option::Option::Some(source) = #varsource { source.thiserror_provide(#request); } } } else { - quote_spanned! {backtrace.member_span()=> + quote_spanned! {backtrace.span()=> #varsource.thiserror_provide(#request); } }; diff --git a/impl/src/prop.rs b/impl/src/prop.rs index f3026a4..e565759 100644 --- a/impl/src/prop.rs +++ b/impl/src/prop.rs @@ -79,7 +79,7 @@ impl Field<'_> { } else if let Some(from_attr) = &self.attrs.from { from_attr.path().get_ident().unwrap().span() } else { - self.member.member_span() + self.member.span() } } } diff --git a/impl/src/unraw.rs b/impl/src/unraw.rs index 7bdebef..c627661 100644 --- a/impl/src/unraw.rs +++ b/impl/src/unraw.rs @@ -80,7 +80,7 @@ pub enum MemberUnraw { } impl MemberUnraw { - pub fn member_span(&self) -> Span { + pub fn span(&self) -> Span { match self { MemberUnraw::Named(ident) => ident.0.span(), MemberUnraw::Unnamed(index) => index.span, From 67faae44b46715c482fc45fa4e3ee655da3e2a64 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 14:29:25 -0500 Subject: [PATCH 042/131] Add regression test for issue 345 error[E0599]: `test_no_bound_on_named_fmt::Error` doesn't implement `std::fmt::Display` --> tests/test_generics.rs:173:22 | 168 | struct Error { | --------------- method `to_string` not found for this struct because it doesn't satisfy `_: Display` or `_: ToString` ... 173 | assert_eq!(error.to_string(), "..."); | ^^^^^^^^^ `test_no_bound_on_named_fmt::Error` cannot be formatted with the default formatter | = note: the following trait bounds were not satisfied: `test_no_bound_on_named_fmt::Error: std::fmt::Display` which is required by `test_no_bound_on_named_fmt::Error: ToString` = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead note: the trait `std::fmt::Display` must be implemented --> $RUSTUP_HOME/toolchains/nightly-aarch64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/fmt/mod.rs:727:1 | 727 | pub trait Display { | ^^^^^^^^^^^^^^^^^ = help: items from traits can only be used if the trait is implemented and in scope = note: the following trait defines an item `to_string`, perhaps you need to implement it: candidate #1: `ToString` --- tests/test_generics.rs | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tests/test_generics.rs b/tests/test_generics.rs index d7790e2..4d49edf 100644 --- a/tests/test_generics.rs +++ b/tests/test_generics.rs @@ -159,3 +159,16 @@ pub struct StructFromGeneric { #[derive(Error, Debug)] #[error(transparent)] pub struct StructTransparentGeneric(pub E); + +// Regression test for https://github.com/dtolnay/thiserror/issues/345 +#[test] +fn test_no_bound_on_named_fmt() { + #[derive(Error, Debug)] + #[error("{thing}", thing = "...")] + struct Error { + thing: T, + } + + let error = Error { thing: DebugOnly }; + assert_eq!(error.to_string(), "..."); +} From 593317939cc2c757de9f759ab66b057201b1681a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 17:20:18 -0500 Subject: [PATCH 043/131] Only apply inferred bounds if interpolation refers to field, not format var --- impl/src/fmt.rs | 43 ++++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 21 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 8b571d9..d555c24 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -69,24 +69,6 @@ impl Display<'_> { } _ => continue, }; - if let Some(&field) = member_index.get(&member) { - let end_spec = match read.find('}') { - Some(end_spec) => end_spec, - None => return, - }; - let bound = match read[..end_spec].chars().next_back() { - Some('?') => Trait::Debug, - Some('o') => Trait::Octal, - Some('x') => Trait::LowerHex, - Some('X') => Trait::UpperHex, - Some('p') => Trait::Pointer, - Some('b') => Trait::Binary, - Some('e') => Trait::LowerExp, - Some('E') => Trait::UpperExp, - Some(_) | None => Trait::Display, - }; - implied_bounds.insert((field, bound)); - } let formatvar = match &member { MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("_{}", index)), MemberUnraw::Named(ident) => ident.clone(), @@ -101,9 +83,28 @@ impl Display<'_> { } let local = formatvar.to_local(); args.extend(quote_spanned!(span=> #formatvar = #local)); - if read.starts_with('}') && member_index.contains_key(&member) { - has_bonus_display = true; - args.extend(quote_spanned!(span=> .as_display())); + if let Some(&field) = member_index.get(&member) { + let end_spec = match read.find('}') { + Some(end_spec) => end_spec, + None => return, + }; + let bound = match read[..end_spec].chars().next_back() { + Some('?') => Trait::Debug, + Some('o') => Trait::Octal, + Some('x') => Trait::LowerHex, + Some('X') => Trait::UpperHex, + Some('p') => Trait::Pointer, + Some('b') => Trait::Binary, + Some('e') => Trait::LowerExp, + Some('E') => Trait::UpperExp, + Some(_) => Trait::Display, + None => { + has_bonus_display = true; + args.extend(quote_spanned!(span=> .as_display())); + Trait::Display + } + }; + implied_bounds.insert((field, bound)); } has_trailing_comma = false; } From 43844c299b8331545169a9fe29863a80cc13378f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 19:53:41 -0500 Subject: [PATCH 044/131] Move msrv CI to a separate job --- .github/workflows/ci.yml | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5dd92eb..a2b6200 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,7 +24,7 @@ jobs: strategy: fail-fast: false matrix: - rust: [nightly, beta, stable, 1.70.0, 1.61.0] + rust: [nightly, beta, stable, 1.70.0] timeout-minutes: 45 steps: - uses: actions/checkout@v4 @@ -39,13 +39,25 @@ jobs: run: echo RUSTFLAGS=${RUSTFLAGS}\ --cfg=thiserror_nightly_testing >> $GITHUB_ENV if: matrix.rust == 'nightly' - run: cargo test --all - if: matrix.rust != '1.61.0' - uses: actions/upload-artifact@v4 if: matrix.rust == 'nightly' && always() with: name: Cargo.lock path: Cargo.lock + msrv: + name: Rust 1.61.0 + needs: pre_ci + if: needs.pre_ci.outputs.continue + runs-on: ubuntu-latest + timeout-minutes: 45 + steps: + - uses: actions/checkout@v4 + - uses: dtolnay/rust-toolchain@1.61.0 + with: + components: rust-src + - run: cargo check + minimal: name: Minimal versions needs: pre_ci From d3b926132bc15dc49b61276565ce04e41315094f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 14:10:18 -0500 Subject: [PATCH 045/131] Disable numbered access to positional args on tuples --- README.md | 2 +- impl/src/ast.rs | 4 +- impl/src/fmt.rs | 88 ++++++++++++++++++----- src/lib.rs | 2 +- tests/test_display.rs | 2 +- tests/ui/numbered-positional-tuple.rs | 7 ++ tests/ui/numbered-positional-tuple.stderr | 5 ++ 7 files changed, 86 insertions(+), 24 deletions(-) create mode 100644 tests/ui/numbered-positional-tuple.rs create mode 100644 tests/ui/numbered-positional-tuple.stderr diff --git a/README.md b/README.md index 54e736d..5082f95 100644 --- a/README.md +++ b/README.md @@ -70,7 +70,7 @@ pub enum DataStoreError { ```rust #[derive(Error, Debug)] pub enum Error { - #[error("invalid rdo_lookahead_frames {0} (expected < {})", i32::MAX)] + #[error("invalid rdo_lookahead_frames {0} (expected < {max})", max = i32::MAX)] InvalidLookahead(u32), } ``` diff --git a/impl/src/ast.rs b/impl/src/ast.rs index 0f9fbeb..df9cf69 100644 --- a/impl/src/ast.rs +++ b/impl/src/ast.rs @@ -60,7 +60,7 @@ impl<'a> Struct<'a> { 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 { - display.expand_shorthand(&fields); + display.expand_shorthand(&fields)?; } Ok(Struct { attrs, @@ -85,7 +85,7 @@ impl<'a> Enum<'a> { display.clone_from(&attrs.display); } if let Some(display) = &mut variant.attrs.display { - display.expand_shorthand(&variant.fields); + display.expand_shorthand(&variant.fields)?; } else if variant.attrs.transparent.is_none() { variant.attrs.transparent = attrs.transparent; } diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index d555c24..22956f0 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -2,22 +2,29 @@ use crate::ast::Field; use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; use crate::unraw::{IdentUnraw, MemberUnraw}; -use proc_macro2::{TokenStream, TokenTree}; +use proc_macro2::{Delimiter, TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet as Set, HashMap as Map}; +use std::iter; use syn::ext::IdentExt; use syn::parse::discouraged::Speculative; -use syn::parse::{ParseStream, Parser}; -use syn::{Expr, Ident, Index, LitStr, Result, Token}; +use syn::parse::{Error, ParseStream, Parser, Result}; +use syn::{Expr, Ident, Index, LitStr, Token}; impl Display<'_> { // Transform `"error {var}"` to `"error {}", var`. - pub fn expand_shorthand(&mut self, fields: &[Field]) { + pub fn expand_shorthand(&mut self, fields: &[Field]) -> Result<()> { let raw_args = self.args.clone(); - let mut named_args = explicit_named_args.parse2(raw_args).unwrap().named; + let FmtArguments { + named: mut named_args, + first_unnamed, + } = explicit_named_args.parse2(raw_args).unwrap(); + let mut member_index = Map::new(); + let mut extra_positional_arguments_allowed = true; for (i, field) in fields.iter().enumerate() { member_index.insert(&field.member, i); + extra_positional_arguments_allowed &= matches!(&field.member, MemberUnraw::Named(_)); } let span = self.fmt.span(); @@ -48,14 +55,20 @@ impl Display<'_> { } let next = match read.chars().next() { Some(next) => next, - None => return, + None => return Ok(()), }; let member = match next { '0'..='9' => { let int = take_int(&mut read); + if !extra_positional_arguments_allowed { + if let Some(first_unnamed) = &first_unnamed { + let msg = "ambiguous reference to positional arguments by number in a tuple struct; change this to a named argument"; + return Err(Error::new_spanned(first_unnamed, msg)); + } + } let member = match int.parse::() { Ok(index) => MemberUnraw::Unnamed(Index { index, span }), - Err(_) => return, + Err(_) => return Ok(()), }; if !member_index.contains_key(&member) { out += int; @@ -86,7 +99,7 @@ impl Display<'_> { if let Some(&field) = member_index.get(&member) { let end_spec = match read.find('}') { Some(end_spec) => end_spec, - None => return, + None => return Ok(()), }; let bound = match read[..end_spec].chars().next_back() { Some('?') => Trait::Debug, @@ -114,12 +127,13 @@ impl Display<'_> { self.args = args; self.has_bonus_display = has_bonus_display; self.implied_bounds = implied_bounds; + Ok(()) } } struct FmtArguments { named: Set, - unnamed: bool, + first_unnamed: Option, } #[allow(clippy::unnecessary_wraps)] @@ -139,7 +153,7 @@ fn explicit_named_args(input: ParseStream) -> Result { input.parse::().unwrap(); Ok(FmtArguments { named: Set::new(), - unnamed: false, + first_unnamed: None, }) } @@ -147,7 +161,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result { let mut syn_full = None; let mut args = FmtArguments { named: Set::new(), - unnamed: false, + first_unnamed: None, }; while !input.is_empty() { @@ -155,21 +169,31 @@ fn try_explicit_named_args(input: ParseStream) -> Result { if input.is_empty() { break; } + + let mut begin_unnamed = None; if input.peek(Ident::peek_any) && input.peek2(Token![=]) && !input.peek2(Token![==]) { let ident: IdentUnraw = input.parse()?; input.parse::()?; args.named.insert(ident); } else { - args.unnamed = true; + begin_unnamed = Some(input.fork()); } - if *syn_full.get_or_insert_with(is_syn_full) { - let ahead = input.fork(); - if ahead.parse::().is_ok() { - input.advance_to(&ahead); - continue; + + let ahead; + if *syn_full.get_or_insert_with(is_syn_full) && { + ahead = input.fork(); + ahead.parse::().is_ok() + } { + input.advance_to(&ahead); + } else { + scan_expr(input)?; + } + + if let Some(begin_unnamed) = begin_unnamed { + if args.first_unnamed.is_none() { + args.first_unnamed = Some(between(&begin_unnamed, input)); } } - scan_expr(input)?; } Ok(args) @@ -178,7 +202,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result { fn fallback_explicit_named_args(input: ParseStream) -> Result { let mut args = FmtArguments { named: Set::new(), - unnamed: false, + first_unnamed: None, }; while !input.is_empty() { @@ -240,3 +264,29 @@ fn take_ident<'a>(read: &mut &'a str) -> &'a str { *read = rest; ident } + +fn between<'a>(begin: ParseStream<'a>, end: ParseStream<'a>) -> TokenStream { + let end = end.cursor(); + let mut cursor = begin.cursor(); + let mut tokens = TokenStream::new(); + + while cursor < end { + let (tt, next) = cursor.token_tree().unwrap(); + + if end < next { + if let Some((inside, _span, _after)) = cursor.group(Delimiter::None) { + cursor = inside; + continue; + } + if tokens.is_empty() { + tokens.extend(iter::once(tt)); + } + break; + } + + tokens.extend(iter::once(tt)); + cursor = next; + } + + tokens +} diff --git a/src/lib.rs b/src/lib.rs index 30715fe..e8b014c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -67,7 +67,7 @@ //! # //! #[derive(Error, Debug)] //! pub enum Error { -//! #[error("invalid rdo_lookahead_frames {0} (expected < {})", i32::MAX)] +//! #[error("invalid rdo_lookahead_frames {0} (expected < {max})", max = i32::MAX)] //! InvalidLookahead(u32), //! } //! ``` diff --git a/tests/test_display.rs b/tests/test_display.rs index 27bb72c..91fe9e0 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -131,7 +131,7 @@ fn test_nested() { #[test] fn test_match() { #[derive(Error, Debug)] - #[error("{}: {0}", match .1 { + #[error("{intro}: {0}", intro = match .1 { Some(n) => format!("error occurred with {}", n), None => "there was an empty error".to_owned(), })] diff --git a/tests/ui/numbered-positional-tuple.rs b/tests/ui/numbered-positional-tuple.rs new file mode 100644 index 0000000..6deb658 --- /dev/null +++ b/tests/ui/numbered-positional-tuple.rs @@ -0,0 +1,7 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("invalid rdo_lookahead_frames {0} (expected < {})", i32::MAX)] +pub struct Error(u32); + +fn main() {} diff --git a/tests/ui/numbered-positional-tuple.stderr b/tests/ui/numbered-positional-tuple.stderr new file mode 100644 index 0000000..ab13371 --- /dev/null +++ b/tests/ui/numbered-positional-tuple.stderr @@ -0,0 +1,5 @@ +error: ambiguous reference to positional arguments by number in a tuple struct; change this to a named argument + --> tests/ui/numbered-positional-tuple.rs:4:61 + | +4 | #[error("invalid rdo_lookahead_frames {0} (expected < {})", i32::MAX)] + | ^^^^^^^^ From 3070b8b6c85e3c575b80a5043c22b55860c2aa54 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 19:48:04 -0500 Subject: [PATCH 046/131] Work around rustc pre-1.74's possibly-uninitialized checker error[E0381]: used binding `ahead` is possibly-uninitialized --> impl/src/fmt.rs:187:30 | 182 | let ahead; | ----- binding declared here but left uninitialized 183 | if *syn_full.get_or_insert_with(is_syn_full) && { 184 | ahead = input.fork(); | ----- | | | binding initialized here in some conditions | binding initialized here in some conditions ... 187 | input.advance_to(&ahead); | ^^^^^^ `ahead` used here but it is possibly-uninitialized --- impl/src/fmt.rs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 22956f0..4a3a064 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -179,11 +179,8 @@ fn try_explicit_named_args(input: ParseStream) -> Result { begin_unnamed = Some(input.fork()); } - let ahead; - if *syn_full.get_or_insert_with(is_syn_full) && { - ahead = input.fork(); - ahead.parse::().is_ok() - } { + let ahead = input.fork(); + if *syn_full.get_or_insert_with(is_syn_full) && ahead.parse::().is_ok() { input.advance_to(&ahead); } else { scan_expr(input)?; From 7e43dec57315870f2ffefa8d7825f15cc7baaa2d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 20:10:27 -0500 Subject: [PATCH 047/131] Improve error message to distinguish tuple struct vs tuple variant --- impl/src/ast.rs | 48 ++++++++++++++++++++++++++++++++++++++++++++++-- impl/src/fmt.rs | 6 +++--- 2 files changed, 49 insertions(+), 5 deletions(-) diff --git a/impl/src/ast.rs b/impl/src/ast.rs index df9cf69..7d074a0 100644 --- a/impl/src/ast.rs +++ b/impl/src/ast.rs @@ -2,6 +2,7 @@ use crate::attr::{self, Attrs}; use crate::generics::ParamsInScope; use crate::unraw::{IdentUnraw, MemberUnraw}; use proc_macro2::Span; +use std::fmt::{self, Display}; use syn::{ Data, DataEnum, DataStruct, DeriveInput, Error, Fields, Generics, Ident, Index, Result, Type, }; @@ -40,6 +41,16 @@ pub struct Field<'a> { 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 { match &node.data { @@ -60,7 +71,8 @@ impl<'a> Struct<'a> { 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 { - display.expand_shorthand(&fields)?; + let container = ContainerKind::from_struct(data); + display.expand_shorthand(&fields, container)?; } Ok(Struct { attrs, @@ -85,7 +97,8 @@ impl<'a> Enum<'a> { display.clone_from(&attrs.display); } if let Some(display) = &mut variant.attrs.display { - display.expand_shorthand(&variant.fields)?; + let container = ContainerKind::from_variant(node); + display.expand_shorthand(&variant.fields, container)?; } else if variant.attrs.transparent.is_none() { variant.attrs.transparent = attrs.transparent; } @@ -149,6 +162,37 @@ impl<'a> Field<'a> { } } +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", + }) + } +} + impl Attrs<'_> { pub fn span(&self) -> Option { if let Some(display) = &self.display { diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 4a3a064..f46c128 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -1,4 +1,4 @@ -use crate::ast::Field; +use crate::ast::{ContainerKind, Field}; use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; use crate::unraw::{IdentUnraw, MemberUnraw}; @@ -13,7 +13,7 @@ use syn::{Expr, Ident, Index, LitStr, Token}; impl Display<'_> { // Transform `"error {var}"` to `"error {}", var`. - pub fn expand_shorthand(&mut self, fields: &[Field]) -> Result<()> { + pub fn expand_shorthand(&mut self, fields: &[Field], container: ContainerKind) -> Result<()> { let raw_args = self.args.clone(); let FmtArguments { named: mut named_args, @@ -62,7 +62,7 @@ impl Display<'_> { let int = take_int(&mut read); if !extra_positional_arguments_allowed { if let Some(first_unnamed) = &first_unnamed { - let msg = "ambiguous reference to positional arguments by number in a tuple struct; change this to a named argument"; + let msg = format!("ambiguous reference to positional arguments by number in a {container}; change this to a named argument"); return Err(Error::new_spanned(first_unnamed, msg)); } } From 51ccdf18f51b501c51faa9f9181d4a87aefea78f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 20:48:22 -0500 Subject: [PATCH 048/131] Slightly cleaner implementation of has_trailing_comma --- impl/src/fmt.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index f46c128..bc6f3dc 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -37,9 +37,7 @@ impl Display<'_> { let mut has_trailing_comma = false; if let Some(TokenTree::Punct(punct)) = args.clone().into_iter().last() { - if punct.as_char() == ',' { - has_trailing_comma = true; - } + has_trailing_comma = punct.as_char() == ','; } self.requires_fmt_machinery = self.requires_fmt_machinery || fmt.contains('}'); From f8fd1bf1969926b8b19c94c4f1c998f552351499 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 21:08:09 -0500 Subject: [PATCH 049/131] Fix collision of numbered field references with user-written named arg --- impl/src/fmt.rs | 18 +++++++++--------- impl/src/unraw.rs | 1 + 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index bc6f3dc..d049fd8 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -4,7 +4,7 @@ use crate::scan_expr::scan_expr; use crate::unraw::{IdentUnraw, MemberUnraw}; use proc_macro2::{Delimiter, TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; -use std::collections::{BTreeSet as Set, HashMap as Map}; +use std::collections::{BTreeSet, HashMap as Map, HashSet}; use std::iter; use syn::ext::IdentExt; use syn::parse::discouraged::Speculative; @@ -33,7 +33,7 @@ impl Display<'_> { let mut out = String::new(); let mut args = self.args.clone(); let mut has_bonus_display = false; - let mut implied_bounds = Set::new(); + let mut implied_bounds = BTreeSet::new(); let mut has_trailing_comma = false; if let Some(TokenTree::Punct(punct)) = args.clone().into_iter().last() { @@ -85,7 +85,7 @@ impl Display<'_> { MemberUnraw::Named(ident) => ident.clone(), }; out += &formatvar.to_string(); - if !named_args.insert(formatvar.clone()) { + if !named_args.insert(member.clone()) { // Already specified in the format argument list. continue; } @@ -130,7 +130,7 @@ impl Display<'_> { } struct FmtArguments { - named: Set, + named: HashSet, first_unnamed: Option, } @@ -150,7 +150,7 @@ fn explicit_named_args(input: ParseStream) -> Result { input.parse::().unwrap(); Ok(FmtArguments { - named: Set::new(), + named: HashSet::new(), first_unnamed: None, }) } @@ -158,7 +158,7 @@ fn explicit_named_args(input: ParseStream) -> Result { fn try_explicit_named_args(input: ParseStream) -> Result { let mut syn_full = None; let mut args = FmtArguments { - named: Set::new(), + named: HashSet::new(), first_unnamed: None, }; @@ -172,7 +172,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result { if input.peek(Ident::peek_any) && input.peek2(Token![=]) && !input.peek2(Token![==]) { let ident: IdentUnraw = input.parse()?; input.parse::()?; - args.named.insert(ident); + args.named.insert(MemberUnraw::Named(ident)); } else { begin_unnamed = Some(input.fork()); } @@ -196,7 +196,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result { fn fallback_explicit_named_args(input: ParseStream) -> Result { let mut args = FmtArguments { - named: Set::new(), + named: HashSet::new(), first_unnamed: None, }; @@ -209,7 +209,7 @@ fn fallback_explicit_named_args(input: ParseStream) -> Result { input.parse::()?; let ident: IdentUnraw = input.parse()?; input.parse::()?; - args.named.insert(ident); + args.named.insert(MemberUnraw::Named(ident)); } } diff --git a/impl/src/unraw.rs b/impl/src/unraw.rs index c627661..267bd02 100644 --- a/impl/src/unraw.rs +++ b/impl/src/unraw.rs @@ -74,6 +74,7 @@ impl ToTokens for IdentUnraw { } } +#[derive(Clone)] pub enum MemberUnraw { Named(IdentUnraw), Unnamed(Index), From 4a79e0121e66bd255ee4a485d474724d54d6ce37 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 20:43:19 -0500 Subject: [PATCH 050/131] Rewrite fmt expansion to exactly preserve user-provided args --- impl/src/attr.rs | 16 +++++++- impl/src/fmt.rs | 60 +++++++++++++++--------------- tests/ui/display-underscore.stderr | 8 ++-- tests/ui/raw-identifier.stderr | 17 +++++---- 4 files changed, 59 insertions(+), 42 deletions(-) diff --git a/impl/src/attr.rs b/impl/src/attr.rs index c28761c..85af18b 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -24,6 +24,7 @@ pub struct Display<'a> { pub requires_fmt_machinery: bool, pub has_bonus_display: bool, pub implied_bounds: Set<(usize, Trait)>, + pub bindings: Vec<(Ident, TokenStream)>, } #[derive(Copy, Clone)] @@ -127,6 +128,7 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu requires_fmt_machinery, has_bonus_display: false, implied_bounds: Set::new(), + bindings: Vec::new(), }; if attrs.display.is_some() { return Err(Error::new_spanned( @@ -253,7 +255,7 @@ impl ToTokens for Display<'_> { // Currently `write!(f, "text")` produces less efficient code than // `f.write_str("text")`. We recognize the case when the format string // has no braces and no interpolated values, and generate simpler code. - tokens.extend(if self.requires_fmt_machinery { + let write = if self.requires_fmt_machinery { quote! { ::core::write!(__formatter, #fmt #args) } @@ -261,6 +263,18 @@ impl ToTokens for Display<'_> { quote! { __formatter.write_str(#fmt) } + }; + + tokens.extend(if self.bindings.is_empty() { + write + } else { + let locals = self.bindings.iter().map(|(local, _value)| local); + let values = self.bindings.iter().map(|(_local, value)| value); + quote! { + match (#(#values,)*) { + (#(#locals,)*) => #write + } + } }); } } diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index d049fd8..d984bfd 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -2,9 +2,9 @@ use crate::ast::{ContainerKind, Field}; use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; use crate::unraw::{IdentUnraw, MemberUnraw}; -use proc_macro2::{Delimiter, TokenStream, TokenTree}; -use quote::{format_ident, quote, quote_spanned}; -use std::collections::{BTreeSet, HashMap as Map, HashSet}; +use proc_macro2::{Delimiter, TokenStream}; +use quote::{format_ident, quote, quote_spanned, ToTokens}; +use std::collections::{BTreeSet, HashMap, HashSet}; use std::iter; use syn::ext::IdentExt; use syn::parse::discouraged::Speculative; @@ -12,15 +12,14 @@ use syn::parse::{Error, ParseStream, Parser, Result}; use syn::{Expr, Ident, Index, LitStr, Token}; impl Display<'_> { - // Transform `"error {var}"` to `"error {}", var`. pub fn expand_shorthand(&mut self, fields: &[Field], container: ContainerKind) -> Result<()> { let raw_args = self.args.clone(); let FmtArguments { - named: mut named_args, + named: user_named_args, first_unnamed, } = explicit_named_args.parse2(raw_args).unwrap(); - let mut member_index = Map::new(); + let mut member_index = HashMap::new(); let mut extra_positional_arguments_allowed = true; for (i, field) in fields.iter().enumerate() { member_index.insert(&field.member, i); @@ -31,14 +30,10 @@ impl Display<'_> { let fmt = self.fmt.value(); let mut read = fmt.as_str(); let mut out = String::new(); - let mut args = self.args.clone(); let mut has_bonus_display = false; let mut implied_bounds = BTreeSet::new(); - - let mut has_trailing_comma = false; - if let Some(TokenTree::Punct(punct)) = args.clone().into_iter().last() { - has_trailing_comma = punct.as_char() == ','; - } + let mut bindings = Vec::new(); + let mut macro_named_args = HashSet::new(); self.requires_fmt_machinery = self.requires_fmt_machinery || fmt.contains('}'); @@ -81,19 +76,26 @@ impl Display<'_> { _ => continue, }; let formatvar = match &member { - MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("_{}", index)), - MemberUnraw::Named(ident) => ident.clone(), + MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("__field{}", index)), + MemberUnraw::Named(ident) => { + if user_named_args.contains(ident) { + // Refers to a named argument written by the user, not to field. + out += &ident.to_string(); + continue; + } + IdentUnraw::new(format_ident!("__field_{}", ident.to_string())) + } }; out += &formatvar.to_string(); - if !named_args.insert(member.clone()) { - // Already specified in the format argument list. + if !macro_named_args.insert(member.clone()) { + // Already added to scope by a previous use. continue; } - if !has_trailing_comma { - args.extend(quote_spanned!(span=> ,)); - } let local = formatvar.to_local(); - args.extend(quote_spanned!(span=> #formatvar = #local)); + let mut binding_value = ToTokens::into_token_stream(match &member { + MemberUnraw::Unnamed(index) => format_ident!("_{}", index), + MemberUnraw::Named(ident) => ident.to_local(), + }); if let Some(&field) = member_index.get(&member) { let end_spec = match read.find('}') { Some(end_spec) => end_spec, @@ -111,26 +113,26 @@ impl Display<'_> { Some(_) => Trait::Display, None => { has_bonus_display = true; - args.extend(quote_spanned!(span=> .as_display())); + binding_value.extend(quote_spanned!(span=> .as_display())); Trait::Display } }; implied_bounds.insert((field, bound)); } - has_trailing_comma = false; + bindings.push((local, binding_value)); } out += read; self.fmt = LitStr::new(&out, self.fmt.span()); - self.args = args; self.has_bonus_display = has_bonus_display; self.implied_bounds = implied_bounds; + self.bindings = bindings; Ok(()) } } struct FmtArguments { - named: HashSet, + named: BTreeSet, first_unnamed: Option, } @@ -150,7 +152,7 @@ fn explicit_named_args(input: ParseStream) -> Result { input.parse::().unwrap(); Ok(FmtArguments { - named: HashSet::new(), + named: BTreeSet::new(), first_unnamed: None, }) } @@ -158,7 +160,7 @@ fn explicit_named_args(input: ParseStream) -> Result { fn try_explicit_named_args(input: ParseStream) -> Result { let mut syn_full = None; let mut args = FmtArguments { - named: HashSet::new(), + named: BTreeSet::new(), first_unnamed: None, }; @@ -172,7 +174,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result { if input.peek(Ident::peek_any) && input.peek2(Token![=]) && !input.peek2(Token![==]) { let ident: IdentUnraw = input.parse()?; input.parse::()?; - args.named.insert(MemberUnraw::Named(ident)); + args.named.insert(ident); } else { begin_unnamed = Some(input.fork()); } @@ -196,7 +198,7 @@ fn try_explicit_named_args(input: ParseStream) -> Result { fn fallback_explicit_named_args(input: ParseStream) -> Result { let mut args = FmtArguments { - named: HashSet::new(), + named: BTreeSet::new(), first_unnamed: None, }; @@ -209,7 +211,7 @@ fn fallback_explicit_named_args(input: ParseStream) -> Result { input.parse::()?; let ident: IdentUnraw = input.parse()?; input.parse::()?; - args.named.insert(MemberUnraw::Named(ident)); + args.named.insert(ident); } } diff --git a/tests/ui/display-underscore.stderr b/tests/ui/display-underscore.stderr index 36882b9..3935970 100644 --- a/tests/ui/display-underscore.stderr +++ b/tests/ui/display-underscore.stderr @@ -1,7 +1,5 @@ -error: invalid format string: invalid argument name `_` - --> tests/ui/display-underscore.rs:4:11 +error: in expressions, `_` can only be used on the left-hand side of an assignment + --> tests/ui/display-underscore.rs:4:9 | 4 | #[error("{_}")] - | ^ invalid argument name in format string - | - = note: argument name cannot be a single underscore + | ^^^^^ `_` not allowed here diff --git a/tests/ui/raw-identifier.stderr b/tests/ui/raw-identifier.stderr index a3ce94d..ffce3fe 100644 --- a/tests/ui/raw-identifier.stderr +++ b/tests/ui/raw-identifier.stderr @@ -1,13 +1,10 @@ -error: invalid format string: raw identifiers are not supported - --> tests/ui/raw-identifier.rs:4:18 +error: invalid format string: expected `}`, found `#` + --> tests/ui/raw-identifier.rs:4:9 | 4 | #[error("error: {r#fn}")] - | --^^ - | | - | raw identifier used here in format string - | help: remove the `r#` + | ^^^^^^^^^^^^^^^ expected `}` in format string | - = note: identifiers in format strings can be keywords and don't need to be prefixed with `r#` + = note: if you intended to print `{`, you can escape it using `{{` error: invalid format string: raw identifiers are not supported --> tests/ui/raw-identifier.rs:11:30 @@ -19,3 +16,9 @@ error: invalid format string: raw identifiers are not supported | help: remove the `r#` | = note: identifiers in format strings can be keywords and don't need to be prefixed with `r#` + +error[E0425]: cannot find value `r` in this scope + --> tests/ui/raw-identifier.rs:4:9 + | +4 | #[error("error: {r#fn}")] + | ^^^^^^^^^^^^^^^ not found in this scope From 58cc36e69f0a7b67b85692e8dc38a81273b839b9 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 22:00:42 -0500 Subject: [PATCH 051/131] Improve diagnostic on {_} in format string --- impl/src/fmt.rs | 2 +- tests/ui/display-underscore.stderr | 8 +++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index d984bfd..6b1e7fa 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -78,7 +78,7 @@ impl Display<'_> { let formatvar = match &member { MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("__field{}", index)), MemberUnraw::Named(ident) => { - if user_named_args.contains(ident) { + if user_named_args.contains(ident) || ident == "_" { // Refers to a named argument written by the user, not to field. out += &ident.to_string(); continue; diff --git a/tests/ui/display-underscore.stderr b/tests/ui/display-underscore.stderr index 3935970..36882b9 100644 --- a/tests/ui/display-underscore.stderr +++ b/tests/ui/display-underscore.stderr @@ -1,5 +1,7 @@ -error: in expressions, `_` can only be used on the left-hand side of an assignment - --> tests/ui/display-underscore.rs:4:9 +error: invalid format string: invalid argument name `_` + --> tests/ui/display-underscore.rs:4:11 | 4 | #[error("{_}")] - | ^^^^^ `_` not allowed here + | ^ invalid argument name in format string + | + = note: argument name cannot be a single underscore From bf6efce84df7d0683bb39eea4eeb623146df469a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 22:03:43 -0500 Subject: [PATCH 052/131] Improve diagnostic on raw identifier in format string --- impl/src/fmt.rs | 3 +++ tests/ui/raw-identifier.stderr | 17 +++++++---------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 6b1e7fa..49e77c5 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -70,6 +70,9 @@ impl Display<'_> { member } 'a'..='z' | 'A'..='Z' | '_' => { + if read.starts_with("r#") { + continue; + } let ident = Ident::new(take_ident(&mut read), span); MemberUnraw::Named(IdentUnraw::new(ident)) } diff --git a/tests/ui/raw-identifier.stderr b/tests/ui/raw-identifier.stderr index ffce3fe..a3ce94d 100644 --- a/tests/ui/raw-identifier.stderr +++ b/tests/ui/raw-identifier.stderr @@ -1,10 +1,13 @@ -error: invalid format string: expected `}`, found `#` - --> tests/ui/raw-identifier.rs:4:9 +error: invalid format string: raw identifiers are not supported + --> tests/ui/raw-identifier.rs:4:18 | 4 | #[error("error: {r#fn}")] - | ^^^^^^^^^^^^^^^ expected `}` in format string + | --^^ + | | + | raw identifier used here in format string + | help: remove the `r#` | - = note: if you intended to print `{`, you can escape it using `{{` + = note: identifiers in format strings can be keywords and don't need to be prefixed with `r#` error: invalid format string: raw identifiers are not supported --> tests/ui/raw-identifier.rs:11:30 @@ -16,9 +19,3 @@ error: invalid format string: raw identifiers are not supported | help: remove the `r#` | = note: identifiers in format strings can be keywords and don't need to be prefixed with `r#` - -error[E0425]: cannot find value `r` in this scope - --> tests/ui/raw-identifier.rs:4:9 - | -4 | #[error("error: {r#fn}")] - | ^^^^^^^^^^^^^^^ not found in this scope From e44fd920651ae753a71f17c51ce96fce74b2313c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 22:08:43 -0500 Subject: [PATCH 053/131] Further deconflict macro-generated format var names with user-provided ones --- impl/src/fmt.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 49e77c5..1c59d10 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -78,7 +78,7 @@ impl Display<'_> { } _ => continue, }; - let formatvar = match &member { + let mut formatvar = match &member { MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("__field{}", index)), MemberUnraw::Named(ident) => { if user_named_args.contains(ident) || ident == "_" { @@ -89,6 +89,9 @@ impl Display<'_> { IdentUnraw::new(format_ident!("__field_{}", ident.to_string())) } }; + while user_named_args.contains(&formatvar) { + formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); + } out += &formatvar.to_string(); if !macro_named_args.insert(member.clone()) { // Already added to scope by a previous use. From 6a0eb08569a951d0bd9a1f67d7b8e733c130b997 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 22:18:46 -0500 Subject: [PATCH 054/131] Recognize infinite recursion caused by {self} --- impl/src/fmt.rs | 47 +++++++++++++++---------- impl/src/unraw.rs | 9 +++++ tests/ui/unconditional-recursion.rs | 9 +++++ tests/ui/unconditional-recursion.stderr | 21 +++++++++++ 4 files changed, 68 insertions(+), 18 deletions(-) create mode 100644 tests/ui/unconditional-recursion.rs create mode 100644 tests/ui/unconditional-recursion.stderr diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 1c59d10..baff7e0 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -102,29 +102,40 @@ impl Display<'_> { MemberUnraw::Unnamed(index) => format_ident!("_{}", index), MemberUnraw::Named(ident) => ident.to_local(), }); - if let Some(&field) = member_index.get(&member) { - let end_spec = match read.find('}') { - Some(end_spec) => end_spec, - None => return Ok(()), - }; - let bound = match read[..end_spec].chars().next_back() { - Some('?') => Trait::Debug, - Some('o') => Trait::Octal, - Some('x') => Trait::LowerHex, - Some('X') => Trait::UpperHex, - Some('p') => Trait::Pointer, - Some('b') => Trait::Binary, - Some('e') => Trait::LowerExp, - Some('E') => Trait::UpperExp, - Some(_) => Trait::Display, - None => { + let end_spec = match read.find('}') { + Some(end_spec) => end_spec, + None => return Ok(()), + }; + let bound = match read[..end_spec].chars().next_back() { + Some('?') => Trait::Debug, + Some('o') => Trait::Octal, + Some('x') => Trait::LowerHex, + Some('X') => Trait::UpperHex, + Some('p') => Trait::Pointer, + Some('b') => Trait::Binary, + Some('e') => Trait::LowerExp, + Some('E') => Trait::UpperExp, + Some(_) => Trait::Display, + None => { + if member_index.contains_key(&member) { has_bonus_display = true; binding_value.extend(quote_spanned!(span=> .as_display())); - Trait::Display } - }; + Trait::Display + } + }; + if let Some(&field) = member_index.get(&member) { implied_bounds.insert((field, bound)); } + if member == *"self" && bound == Trait::Display { + binding_value = quote_spanned!(member.span()=> + { + #[warn(unconditional_recursion)] + fn _fmt() { _fmt() } + #member + } + ); + } bindings.push((local, binding_value)); } diff --git a/impl/src/unraw.rs b/impl/src/unraw.rs index 267bd02..c459b69 100644 --- a/impl/src/unraw.rs +++ b/impl/src/unraw.rs @@ -101,6 +101,15 @@ impl PartialEq for MemberUnraw { } } +impl PartialEq for MemberUnraw { + fn eq(&self, other: &str) -> bool { + match self { + MemberUnraw::Named(this) => this == other, + MemberUnraw::Unnamed(_) => false, + } + } +} + impl Hash for MemberUnraw { fn hash(&self, hasher: &mut H) { match self { diff --git a/tests/ui/unconditional-recursion.rs b/tests/ui/unconditional-recursion.rs new file mode 100644 index 0000000..9e406e8 --- /dev/null +++ b/tests/ui/unconditional-recursion.rs @@ -0,0 +1,9 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("{self}")] +pub struct Error; + +fn main() { + @//fail +} diff --git a/tests/ui/unconditional-recursion.stderr b/tests/ui/unconditional-recursion.stderr new file mode 100644 index 0000000..72ee5dc --- /dev/null +++ b/tests/ui/unconditional-recursion.stderr @@ -0,0 +1,21 @@ +error: expected expression, found `@` + --> tests/ui/unconditional-recursion.rs:8:5 + | +8 | @//fail + | ^ expected expression + +warning: function cannot return without recursing + --> tests/ui/unconditional-recursion.rs:4:9 + | +4 | #[error("{self}")] + | ^^^^^^^^ + | | + | cannot return without recursing + | recursive call site + | + = help: a `loop` may express intention better if this is on purpose +note: the lint level is defined here + --> tests/ui/unconditional-recursion.rs:4:9 + | +4 | #[error("{self}")] + | ^^^^^^^^ From 9d7602e22668dae9124e80bd269a5b3afc5f5512 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 23:31:14 -0500 Subject: [PATCH 055/131] Remove same_member in favor of MemberUnraw's PartialEq impl --- impl/src/valid.rs | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/impl/src/valid.rs b/impl/src/valid.rs index 3b475af..1ddb19e 100644 --- a/impl/src/valid.rs +++ b/impl/src/valid.rs @@ -1,6 +1,5 @@ use crate::ast::{Enum, Field, Input, Struct, Variant}; use crate::attr::Attrs; -use crate::unraw::MemberUnraw; use quote::ToTokens; use std::collections::BTreeSet as Set; use syn::{Error, GenericArgument, PathArguments, Result, Type}; @@ -173,7 +172,7 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> { has_backtrace |= field.is_backtrace(); } if let (Some(from_field), Some(source_field)) = (from_field, source_field) { - if !same_member(from_field, source_field) { + if from_field.member != source_field.member { return Err(Error::new_spanned( from_field.attrs.from, "#[from] is only supported on the source field, not any other field", @@ -182,7 +181,7 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> { } if let Some(from_field) = from_field { let max_expected_fields = match backtrace_field { - Some(backtrace_field) => 1 + !same_member(from_field, backtrace_field) as usize, + Some(backtrace_field) => 1 + (from_field.member != backtrace_field.member) as usize, None => 1 + has_backtrace as usize, }; if fields.len() > max_expected_fields { @@ -203,14 +202,6 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> { Ok(()) } -fn same_member(one: &Field, two: &Field) -> bool { - match (&one.member, &two.member) { - (MemberUnraw::Named(one), MemberUnraw::Named(two)) => one == two, - (MemberUnraw::Unnamed(one), MemberUnraw::Unnamed(two)) => one.index == two.index, - _ => unreachable!(), - } -} - fn contains_non_static_lifetime(ty: &Type) -> bool { match ty { Type::Path(ty) => { From 8b663dc3ea96d4a64ce8f55ec8fb6ab543e69b4a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 23:47:27 -0500 Subject: [PATCH 056/131] Add ui test of colliding From impls --- tests/ui/same-from-type.rs | 11 +++++++++++ tests/ui/same-from-type.stderr | 5 +++++ 2 files changed, 16 insertions(+) create mode 100644 tests/ui/same-from-type.rs create mode 100644 tests/ui/same-from-type.stderr diff --git a/tests/ui/same-from-type.rs b/tests/ui/same-from-type.rs new file mode 100644 index 0000000..bc32b07 --- /dev/null +++ b/tests/ui/same-from-type.rs @@ -0,0 +1,11 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum Error { + #[error("failed to open")] + OpenFile(#[from] std::io::Error), + #[error("failed to close")] + CloseFIle(#[from] std::io::Error), +} + +fn main() {} diff --git a/tests/ui/same-from-type.stderr b/tests/ui/same-from-type.stderr new file mode 100644 index 0000000..1e33385 --- /dev/null +++ b/tests/ui/same-from-type.stderr @@ -0,0 +1,5 @@ +error: cannot derive From because another variant has the same source type + --> tests/ui/same-from-type.rs:8:15 + | +8 | CloseFIle(#[from] std::io::Error), + | ^^^^^^^^^^^^^^^^^^^^^^ From 5ffcf461e7203f5f60347bb758200c5a874cec7f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 23:58:14 -0500 Subject: [PATCH 057/131] Store span of #[source] and #[from] attribute --- impl/src/attr.rs | 26 ++++++++++++++++++++++---- impl/src/prop.rs | 4 ++-- impl/src/valid.rs | 22 ++++++++++++++-------- 3 files changed, 38 insertions(+), 14 deletions(-) diff --git a/impl/src/attr.rs b/impl/src/attr.rs index 85af18b..db618b4 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -10,9 +10,9 @@ use syn::{ pub struct Attrs<'a> { pub display: Option>, - pub source: Option<&'a Attribute>, + pub source: Option>, pub backtrace: Option<&'a Attribute>, - pub from: Option<&'a Attribute>, + pub from: Option>, pub transparent: Option>, } @@ -27,6 +27,18 @@ pub struct Display<'a> { pub bindings: Vec<(Ident, TokenStream)>, } +#[derive(Copy, Clone)] +pub struct Source<'a> { + pub original: &'a Attribute, + pub span: Span, +} + +#[derive(Copy, Clone)] +pub struct From<'a> { + pub original: &'a Attribute, + pub span: Span, +} + #[derive(Copy, Clone)] pub struct Transparent<'a> { pub original: &'a Attribute, @@ -63,7 +75,10 @@ pub fn get(input: &[Attribute]) -> Result { if attrs.source.is_some() { return Err(Error::new_spanned(attr, "duplicate #[source] attribute")); } - attrs.source = Some(attr); + attrs.source = Some(Source { + original: attr, + span: attr.path().get_ident().unwrap().span(), + }); } else if attr.path().is_ident("backtrace") { attr.meta.require_path_only()?; if attrs.backtrace.is_some() { @@ -81,7 +96,10 @@ pub fn get(input: &[Attribute]) -> Result { if attrs.from.is_some() { return Err(Error::new_spanned(attr, "duplicate #[from] attribute")); } - attrs.from = Some(attr); + attrs.from = Some(From { + original: attr, + span: attr.path().get_ident().unwrap().span(), + }); } } diff --git a/impl/src/prop.rs b/impl/src/prop.rs index e565759..56ab0c5 100644 --- a/impl/src/prop.rs +++ b/impl/src/prop.rs @@ -75,9 +75,9 @@ impl Field<'_> { pub(crate) fn source_span(&self) -> Span { if let Some(source_attr) = &self.attrs.source { - source_attr.path().get_ident().unwrap().span() + source_attr.span } else if let Some(from_attr) = &self.attrs.from { - from_attr.path().get_ident().unwrap().span() + from_attr.span } else { self.member.span() } diff --git a/impl/src/valid.rs b/impl/src/valid.rs index 1ddb19e..b1d6d56 100644 --- a/impl/src/valid.rs +++ b/impl/src/valid.rs @@ -25,7 +25,7 @@ impl Struct<'_> { } if let Some(source) = self.fields.iter().find_map(|f| f.attrs.source) { return Err(Error::new_spanned( - source, + source.original, "transparent error struct can't contain #[source]", )); } @@ -80,7 +80,7 @@ impl Variant<'_> { } if let Some(source) = self.fields.iter().find_map(|f| f.attrs.source) { return Err(Error::new_spanned( - source, + source.original, "transparent variant can't contain #[source]", )); } @@ -108,13 +108,13 @@ impl Field<'_> { fn check_non_field_attrs(attrs: &Attrs) -> Result<()> { if let Some(from) = &attrs.from { return Err(Error::new_spanned( - from, + from.original, "not expected here; the #[from] attribute belongs on a specific field", )); } if let Some(source) = &attrs.source { return Err(Error::new_spanned( - source, + source.original, "not expected here; the #[source] attribute belongs on a specific field", )); } @@ -143,13 +143,19 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> { for field in fields { if let Some(from) = field.attrs.from { if from_field.is_some() { - return Err(Error::new_spanned(from, "duplicate #[from] attribute")); + return Err(Error::new_spanned( + from.original, + "duplicate #[from] attribute", + )); } from_field = Some(field); } if let Some(source) = field.attrs.source { if source_field.is_some() { - return Err(Error::new_spanned(source, "duplicate #[source] attribute")); + return Err(Error::new_spanned( + source.original, + "duplicate #[source] attribute", + )); } source_field = Some(field); } @@ -174,7 +180,7 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> { if let (Some(from_field), Some(source_field)) = (from_field, source_field) { if from_field.member != source_field.member { return Err(Error::new_spanned( - from_field.attrs.from, + from_field.attrs.from.unwrap().original, "#[from] is only supported on the source field, not any other field", )); } @@ -186,7 +192,7 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> { }; if fields.len() > max_expected_fields { return Err(Error::new_spanned( - from_field.attrs.from, + from_field.attrs.from.unwrap().original, "deriving From requires no fields other than source and backtrace", )); } From b49f6472995af55a0017ca9d07769ab81da53231 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 00:13:52 -0500 Subject: [PATCH 058/131] Try joining a span for #[source] and #[from] --- impl/src/attr.rs | 10 ++++++++-- tests/ui/source-enum-unnamed-field-not-error.stderr | 4 ++-- tests/ui/source-struct-unnamed-field-not-error.stderr | 4 ++-- 3 files changed, 12 insertions(+), 6 deletions(-) diff --git a/impl/src/attr.rs b/impl/src/attr.rs index db618b4..2fc04af 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -75,9 +75,12 @@ pub fn get(input: &[Attribute]) -> Result { if attrs.source.is_some() { return Err(Error::new_spanned(attr, "duplicate #[source] attribute")); } + let span = (attr.pound_token.span) + .join(attr.bracket_token.span.join()) + .unwrap_or(attr.path().get_ident().unwrap().span()); attrs.source = Some(Source { original: attr, - span: attr.path().get_ident().unwrap().span(), + span, }); } else if attr.path().is_ident("backtrace") { attr.meta.require_path_only()?; @@ -96,9 +99,12 @@ pub fn get(input: &[Attribute]) -> Result { if attrs.from.is_some() { return Err(Error::new_spanned(attr, "duplicate #[from] attribute")); } + let span = (attr.pound_token.span) + .join(attr.bracket_token.span.join()) + .unwrap_or(attr.path().get_ident().unwrap().span()); attrs.from = Some(From { original: attr, - span: attr.path().get_ident().unwrap().span(), + span, }); } } diff --git a/tests/ui/source-enum-unnamed-field-not-error.stderr b/tests/ui/source-enum-unnamed-field-not-error.stderr index a1fe2b5..dc97a4b 100644 --- a/tests/ui/source-enum-unnamed-field-not-error.stderr +++ b/tests/ui/source-enum-unnamed-field-not-error.stderr @@ -1,11 +1,11 @@ error[E0599]: the method `as_dyn_error` exists for reference `&NotError`, but its trait bounds were not satisfied - --> tests/ui/source-enum-unnamed-field-not-error.rs:9:14 + --> tests/ui/source-enum-unnamed-field-not-error.rs:9:12 | 4 | pub struct NotError; | ------------------- doesn't satisfy `NotError: AsDynError<'_>` or `NotError: std::error::Error` ... 9 | Broken(#[source] NotError), - | ^^^^^^ method cannot be called on `&NotError` due to unsatisfied trait bounds + | ^^^^^^^^^ method cannot be called on `&NotError` due to unsatisfied trait bounds | = note: the following trait bounds were not satisfied: `NotError: std::error::Error` diff --git a/tests/ui/source-struct-unnamed-field-not-error.stderr b/tests/ui/source-struct-unnamed-field-not-error.stderr index 2022ea6..1f5350b 100644 --- a/tests/ui/source-struct-unnamed-field-not-error.stderr +++ b/tests/ui/source-struct-unnamed-field-not-error.stderr @@ -1,11 +1,11 @@ error[E0599]: the method `as_dyn_error` exists for struct `NotError`, but its trait bounds were not satisfied - --> tests/ui/source-struct-unnamed-field-not-error.rs:8:26 + --> tests/ui/source-struct-unnamed-field-not-error.rs:8:24 | 4 | struct NotError; | --------------- method `as_dyn_error` not found for this struct because it doesn't satisfy `NotError: AsDynError<'_>` or `NotError: std::error::Error` ... 8 | pub struct ErrorStruct(#[source] NotError); - | ^^^^^^ method cannot be called on `NotError` due to unsatisfied trait bounds + | ^^^^^^^^^ method cannot be called on `NotError` due to unsatisfied trait bounds | = note: the following trait bounds were not satisfied: `NotError: std::error::Error` From 7ca67b01f3eb1e3ceecf13af5667e234ab6b02a3 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 00:19:07 -0500 Subject: [PATCH 059/131] Let rustc generate diagnostic for colliding From impls --- impl/src/valid.rs | 14 -------------- tests/ui/same-from-type.stderr | 13 +++++++++---- 2 files changed, 9 insertions(+), 18 deletions(-) diff --git a/impl/src/valid.rs b/impl/src/valid.rs index b1d6d56..5755b78 100644 --- a/impl/src/valid.rs +++ b/impl/src/valid.rs @@ -1,7 +1,5 @@ use crate::ast::{Enum, Field, Input, Struct, Variant}; use crate::attr::Attrs; -use quote::ToTokens; -use std::collections::BTreeSet as Set; use syn::{Error, GenericArgument, PathArguments, Result, Type}; impl Input<'_> { @@ -52,18 +50,6 @@ impl Enum<'_> { )); } } - let mut from_types = Set::new(); - for variant in &self.variants { - if let Some(from_field) = variant.from_field() { - let repr = from_field.ty.to_token_stream().to_string(); - if !from_types.insert(repr) { - return Err(Error::new_spanned( - from_field.original, - "cannot derive From because another variant has the same source type", - )); - } - } - } Ok(()) } } diff --git a/tests/ui/same-from-type.stderr b/tests/ui/same-from-type.stderr index 1e33385..cf653ea 100644 --- a/tests/ui/same-from-type.stderr +++ b/tests/ui/same-from-type.stderr @@ -1,5 +1,10 @@ -error: cannot derive From because another variant has the same source type - --> tests/ui/same-from-type.rs:8:15 +error[E0119]: conflicting implementations of trait `From` for type `Error` + --> tests/ui/same-from-type.rs:3:10 | -8 | CloseFIle(#[from] std::io::Error), - | ^^^^^^^^^^^^^^^^^^^^^^ +3 | #[derive(Error, Debug)] + | ^^^^^ + | | + | first implementation here + | conflicting implementation for `Error` + | + = note: this error originates in the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info) From 6cac4c078eacd5290b326aafa17e1f22e7fdf677 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 23:57:42 -0500 Subject: [PATCH 060/131] Set span of generated From impls --- impl/src/expand.rs | 28 ++++++++++++++++++---------- tests/ui/same-from-type.stderr | 14 ++++++-------- 2 files changed, 24 insertions(+), 18 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 77f7157..64e7891 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -2,7 +2,7 @@ use crate::ast::{Enum, Field, Input, Struct}; use crate::attr::Trait; use crate::generics::InferredBounds; use crate::unraw::MemberUnraw; -use proc_macro2::TokenStream; +use proc_macro2::{Ident, TokenStream}; use quote::{format_ident, quote, quote_spanned, ToTokens}; use std::collections::BTreeSet as Set; use syn::{DeriveInput, GenericArgument, PathArguments, Result, Token, Type}; @@ -191,15 +191,17 @@ fn impl_struct(input: Struct) -> TokenStream { }); let from_impl = input.from_field().map(|from_field| { + let span = from_field.attrs.from.unwrap().span; let backtrace_field = input.distinct_backtrace_field(); let from = unoptional_type(from_field.ty); - let body = from_initializer(from_field, backtrace_field); - quote! { + let source_var = Ident::new("source", span); + let body = from_initializer(from_field, backtrace_field, &source_var); + quote_spanned! {span=> #[allow(unused_qualifications)] #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { #[allow(deprecated)] - fn from(source: #from) -> Self { + fn from(#source_var: #from) -> Self { #ty #body } } @@ -449,16 +451,18 @@ fn impl_enum(input: Enum) -> TokenStream { let from_impls = input.variants.iter().filter_map(|variant| { let from_field = variant.from_field()?; + let span = from_field.attrs.from.unwrap().span; let backtrace_field = variant.distinct_backtrace_field(); let variant = &variant.ident; let from = unoptional_type(from_field.ty); - let body = from_initializer(from_field, backtrace_field); - Some(quote! { + let source_var = Ident::new("source", span); + let body = from_initializer(from_field, backtrace_field, &source_var); + Some(quote_spanned! {span=> #[allow(unused_qualifications)] #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { #[allow(deprecated)] - fn from(source: #from) -> Self { + fn from(#source_var: #from) -> Self { #ty::#variant #body } } @@ -509,12 +513,16 @@ fn use_as_display(needs_as_display: bool) -> Option { } } -fn from_initializer(from_field: &Field, backtrace_field: Option<&Field>) -> TokenStream { +fn from_initializer( + from_field: &Field, + backtrace_field: Option<&Field>, + source_var: &Ident, +) -> TokenStream { let from_member = &from_field.member; let some_source = if type_is_option(from_field.ty) { - quote!(::core::option::Option::Some(source)) + quote!(::core::option::Option::Some(#source_var)) } else { - quote!(source) + quote!(#source_var) }; let backtrace = backtrace_field.map(|backtrace_field| { let backtrace_member = &backtrace_field.member; diff --git a/tests/ui/same-from-type.stderr b/tests/ui/same-from-type.stderr index cf653ea..92944d2 100644 --- a/tests/ui/same-from-type.stderr +++ b/tests/ui/same-from-type.stderr @@ -1,10 +1,8 @@ error[E0119]: conflicting implementations of trait `From` for type `Error` - --> tests/ui/same-from-type.rs:3:10 + --> tests/ui/same-from-type.rs:8:15 | -3 | #[derive(Error, Debug)] - | ^^^^^ - | | - | first implementation here - | conflicting implementation for `Error` - | - = note: this error originates in the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info) +6 | OpenFile(#[from] std::io::Error), + | ------- first implementation here +7 | #[error("failed to close")] +8 | CloseFIle(#[from] std::io::Error), + | ^^^^^^^ conflicting implementation for `Error` From 7a72593ee3d50604b4b1a046dbb2a9a18256838f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 16:14:41 -0500 Subject: [PATCH 061/131] Delete Attrs::span in favor of just call_site() --- impl/src/ast.rs | 40 ++++++++-------------------------------- 1 file changed, 8 insertions(+), 32 deletions(-) diff --git a/impl/src/ast.rs b/impl/src/ast.rs index 7d074a0..a56b358 100644 --- a/impl/src/ast.rs +++ b/impl/src/ast.rs @@ -68,8 +68,7 @@ impl<'a> Struct<'a> { fn from_syn(node: &'a DeriveInput, data: &'a DataStruct) -> Result { 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)?; + 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)?; @@ -87,12 +86,11 @@ impl<'a> Enum<'a> { fn from_syn(node: &'a DeriveInput, data: &'a DataEnum) -> Result { 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)?; + let mut variant = Variant::from_syn(node, &scope)?; if let display @ None = &mut variant.attrs.display { display.clone_from(&attrs.display); } @@ -115,37 +113,27 @@ impl<'a> Enum<'a> { } impl<'a> Variant<'a> { - fn from_syn(node: &'a syn::Variant, scope: &ParamsInScope<'a>, span: Span) -> Result { + fn from_syn(node: &'a syn::Variant, scope: &ParamsInScope<'a>) -> Result { 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> { + fn multiple_from_syn(fields: &'a Fields, scope: &ParamsInScope<'a>) -> Result> { 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 { + fn from_syn(i: usize, node: &'a syn::Field, scope: &ParamsInScope<'a>) -> Result { Ok(Field { original: node, attrs: attr::get(&node.attrs)?, @@ -153,7 +141,7 @@ impl<'a> Field<'a> { Some(name) => MemberUnraw::Named(IdentUnraw::new(name.clone())), None => MemberUnraw::Unnamed(Index { index: i as u32, - span, + span: Span::call_site(), }), }, ty: &node.ty, @@ -192,15 +180,3 @@ impl Display for ContainerKind { }) } } - -impl Attrs<'_> { - pub fn span(&self) -> Option { - if let Some(display) = &self.display { - Some(display.fmt.span()) - } else if let Some(transparent) = &self.transparent { - Some(transparent.span) - } else { - None - } - } -} From 71adf02435464dfb638f0b45d0caddaab03e318f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 17:02:31 -0500 Subject: [PATCH 062/131] Add test of transparent variant in enum with format args error: cannot have both #[error(transparent)] and a display attribute --> tests/test_transparent.rs:51:5 | 51 | #[error("this failed: {0}_{1}")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ --- tests/test_transparent.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/test_transparent.rs b/tests/test_transparent.rs index 6f3c03e..ee30f5b 100644 --- a/tests/test_transparent.rs +++ b/tests/test_transparent.rs @@ -45,6 +45,24 @@ fn test_transparent_enum() { assert_eq!("inner", error.source().unwrap().to_string()); } +#[test] +fn test_transparent_enum_with_default_message() { + #[derive(Error, Debug)] + #[error("this failed: {0}_{1}")] + enum Error { + This(i32, i32), + #[error(transparent)] + Other(anyhow::Error), + } + + let error = Error::This(-1, -1); + assert_eq!("this failed: -1_-1", error.to_string()); + + let error = Error::Other(anyhow!("inner").context("outer")); + assert_eq!("outer", error.to_string()); + assert_eq!("inner", error.source().unwrap().to_string()); +} + #[test] fn test_anyhow() { #[derive(Error, Debug)] From 65f199026508d9c21cddd194ce32e974e2894ff3 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 16:59:45 -0500 Subject: [PATCH 063/131] Allow error(transparent) inside an enum that has error("...") --- impl/src/ast.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/impl/src/ast.rs b/impl/src/ast.rs index a56b358..5cbae38 100644 --- a/impl/src/ast.rs +++ b/impl/src/ast.rs @@ -91,14 +91,13 @@ impl<'a> Enum<'a> { .iter() .map(|node| { let mut variant = Variant::from_syn(node, &scope)?; - if let display @ None = &mut variant.attrs.display { - display.clone_from(&attrs.display); + if variant.attrs.display.is_none() && variant.attrs.transparent.is_none() { + variant.attrs.display.clone_from(&attrs.display); + variant.attrs.transparent = attrs.transparent; } if let Some(display) = &mut variant.attrs.display { let container = ContainerKind::from_variant(node); display.expand_shorthand(&variant.fields, container)?; - } else if variant.attrs.transparent.is_none() { - variant.attrs.transparent = attrs.transparent; } Ok(variant) }) From ba9af4522e1dd32c281b4035c83067aae9d7dad4 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 4 Nov 2024 23:20:03 -0500 Subject: [PATCH 064/131] Implement #[error(fmt = ...)] --- impl/src/ast.rs | 6 ++- impl/src/attr.rs | 36 +++++++++++++++--- impl/src/expand.rs | 32 +++++++++------- impl/src/prop.rs | 3 +- impl/src/valid.rs | 37 +++++++++++++++--- tests/test_display.rs | 66 +++++++++++++++++++++++++++++++++ tests/ui/concat-display.stderr | 2 +- tests/ui/duplicate-fmt.rs | 15 ++++++++ tests/ui/duplicate-fmt.stderr | 18 +++++++++ tests/ui/struct-with-fmt.rs | 7 ++++ tests/ui/struct-with-fmt.stderr | 5 +++ 11 files changed, 200 insertions(+), 27 deletions(-) create mode 100644 tests/ui/struct-with-fmt.rs create mode 100644 tests/ui/struct-with-fmt.stderr diff --git a/impl/src/ast.rs b/impl/src/ast.rs index 5cbae38..77f9583 100644 --- a/impl/src/ast.rs +++ b/impl/src/ast.rs @@ -91,9 +91,13 @@ impl<'a> Enum<'a> { .iter() .map(|node| { let mut variant = Variant::from_syn(node, &scope)?; - if variant.attrs.display.is_none() && variant.attrs.transparent.is_none() { + 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); diff --git a/impl/src/attr.rs b/impl/src/attr.rs index 2fc04af..f98f731 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -4,8 +4,8 @@ use std::collections::BTreeSet as Set; use syn::parse::discouraged::Speculative; use syn::parse::{End, ParseStream}; use syn::{ - braced, bracketed, parenthesized, token, Attribute, Error, Ident, Index, LitFloat, LitInt, - LitStr, Meta, Result, Token, + braced, bracketed, parenthesized, token, Attribute, Error, ExprPath, Ident, Index, LitFloat, + LitInt, LitStr, Meta, Result, Token, }; pub struct Attrs<'a> { @@ -14,6 +14,7 @@ pub struct Attrs<'a> { pub backtrace: Option<&'a Attribute>, pub from: Option>, pub transparent: Option>, + pub fmt: Option>, } #[derive(Clone)] @@ -45,6 +46,12 @@ pub struct Transparent<'a> { pub span: Span, } +#[derive(Clone)] +pub struct Fmt<'a> { + pub original: &'a Attribute, + pub path: ExprPath, +} + #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)] pub enum Trait { Debug, @@ -65,6 +72,7 @@ pub fn get(input: &[Attribute]) -> Result { backtrace: None, from: None, transparent: None, + fmt: None, }; for attr in input { @@ -113,14 +121,17 @@ pub fn get(input: &[Attribute]) -> Result { } fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Result<()> { - syn::custom_keyword!(transparent); + mod kw { + syn::custom_keyword!(transparent); + syn::custom_keyword!(fmt); + } attr.parse_args_with(|input: ParseStream| { let lookahead = input.lookahead1(); let fmt = if lookahead.peek(LitStr) { input.parse::()? - } else if lookahead.peek(transparent) { - let kw: transparent = input.parse()?; + } else if lookahead.peek(kw::transparent) { + let kw: kw::transparent = input.parse()?; if attrs.transparent.is_some() { return Err(Error::new_spanned( attr, @@ -132,6 +143,21 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu span: kw.span, }); return Ok(()); + } else if lookahead.peek(kw::fmt) { + input.parse::()?; + input.parse::()?; + let path: ExprPath = input.parse()?; + if attrs.fmt.is_some() { + return Err(Error::new_spanned( + attr, + "duplicate #[error(fmt = ...)] attribute", + )); + } + attrs.fmt = Some(Fmt { + original: attr, + path, + }); + return Ok(()); } else { return Err(lookahead.error()); }; diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 64e7891..f6f45f9 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -404,19 +404,23 @@ fn impl_enum(input: Enum) -> TokenStream { }; let arms = input.variants.iter().map(|variant| { let mut display_implied_bounds = Set::new(); - let display = match &variant.attrs.display { - Some(display) => { - display_implied_bounds.clone_from(&display.implied_bounds); - display.to_token_stream() - } - None => { - let only_field = match &variant.fields[0].member { - MemberUnraw::Named(ident) => ident.to_local(), - MemberUnraw::Unnamed(index) => format_ident!("_{}", index), - }; - display_implied_bounds.insert((0, Trait::Display)); - quote!(::core::fmt::Display::fmt(#only_field, __formatter)) - } + let display = if let Some(display) = &variant.attrs.display { + display_implied_bounds.clone_from(&display.implied_bounds); + display.to_token_stream() + } else if let Some(fmt) = &variant.attrs.fmt { + let fmt_path = &fmt.path; + let vars = variant.fields.iter().map(|field| match &field.member { + MemberUnraw::Named(ident) => ident.to_local(), + MemberUnraw::Unnamed(index) => format_ident!("_{}", index), + }); + quote!(#fmt_path(#(#vars,)* __formatter)) + } else { + let only_field = match &variant.fields[0].member { + MemberUnraw::Named(ident) => ident.to_local(), + MemberUnraw::Unnamed(index) => format_ident!("_{}", index), + }; + display_implied_bounds.insert((0, Trait::Display)); + quote!(::core::fmt::Display::fmt(#only_field, __formatter)) }; for (field, bound) in display_implied_bounds { let field = &variant.fields[field]; @@ -494,7 +498,7 @@ fn fields_pat(fields: &[Field]) -> TokenStream { Some(MemberUnraw::Named(_)) => quote!({ #(#members),* }), Some(MemberUnraw::Unnamed(_)) => { let vars = members.map(|member| match member { - MemberUnraw::Unnamed(member) => format_ident!("_{}", member), + MemberUnraw::Unnamed(index) => format_ident!("_{}", index), MemberUnraw::Named(_) => unreachable!(), }); quote!((#(#vars),*)) diff --git a/impl/src/prop.rs b/impl/src/prop.rs index 56ab0c5..0a101fc 100644 --- a/impl/src/prop.rs +++ b/impl/src/prop.rs @@ -38,10 +38,11 @@ impl Enum<'_> { pub(crate) fn has_display(&self) -> bool { self.attrs.display.is_some() || self.attrs.transparent.is_some() + || self.attrs.fmt.is_some() || self .variants .iter() - .any(|variant| variant.attrs.display.is_some()) + .any(|variant| variant.attrs.display.is_some() || variant.attrs.fmt.is_some()) || self .variants .iter() diff --git a/impl/src/valid.rs b/impl/src/valid.rs index 5755b78..21bd885 100644 --- a/impl/src/valid.rs +++ b/impl/src/valid.rs @@ -28,6 +28,12 @@ impl Struct<'_> { )); } } + if let Some(fmt) = &self.attrs.fmt { + return Err(Error::new_spanned( + fmt.original, + "#[error(fmt = ...)] is only supported in enums; for a struct, handwrite your own Display impl", + )); + } check_field_attrs(&self.fields)?; for field in &self.fields { field.validate()?; @@ -42,7 +48,10 @@ impl Enum<'_> { let has_display = self.has_display(); for variant in &self.variants { variant.validate()?; - if has_display && variant.attrs.display.is_none() && variant.attrs.transparent.is_none() + if has_display + && variant.attrs.display.is_none() + && variant.attrs.transparent.is_none() + && variant.attrs.fmt.is_none() { return Err(Error::new_spanned( variant.original, @@ -81,9 +90,15 @@ impl Variant<'_> { impl Field<'_> { fn validate(&self) -> Result<()> { - if let Some(display) = &self.attrs.display { + if let Some(unexpected_display_attr) = if let Some(display) = &self.attrs.display { + Some(display.original) + } else if let Some(fmt) = &self.attrs.fmt { + Some(fmt.original) + } else { + None + } { return Err(Error::new_spanned( - display.original, + unexpected_display_attr, "not expected here; the #[error(...)] attribute belongs on top of a struct or an enum variant", )); } @@ -110,14 +125,26 @@ fn check_non_field_attrs(attrs: &Attrs) -> Result<()> { "not expected here; the #[backtrace] attribute belongs on a specific field", )); } - if let Some(display) = &attrs.display { - if attrs.transparent.is_some() { + if attrs.transparent.is_some() { + if let Some(display) = &attrs.display { return Err(Error::new_spanned( display.original, "cannot have both #[error(transparent)] and a display attribute", )); } + if let Some(fmt) = &attrs.fmt { + return Err(Error::new_spanned( + fmt.original, + "cannot have both #[error(transparent)] and #[error(fmt = ...)]", + )); + } + } else if let (Some(display), Some(_)) = (&attrs.display, &attrs.fmt) { + return Err(Error::new_spanned( + display.original, + "cannot have both #[error(fmt = ...)] and a format arguments attribute", + )); } + Ok(()) } diff --git a/tests/test_display.rs b/tests/test_display.rs index 91fe9e0..ec4170d 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -370,3 +370,69 @@ fn test_raw_str() { assert(r#"raw brace right }"#, Error::BraceRight); assert(r#"raw brace right 2 \x7D"#, Error::BraceRight2); } + +mod util { + use core::fmt::{self, Octal}; + + pub fn octal(value: &T, formatter: &mut fmt::Formatter) -> fmt::Result { + write!(formatter, "0o{:o}", value) + } +} + +#[test] +fn test_fmt_path() { + fn unit(formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.write_str("unit=") + } + + fn pair(k: &i32, v: &i32, formatter: &mut fmt::Formatter) -> fmt::Result { + write!(formatter, "pair={k}:{v}") + } + + #[derive(Error, Debug)] + pub enum Error { + #[error(fmt = unit)] + Unit, + #[error(fmt = pair)] + Tuple(i32, i32), + #[error(fmt = pair)] + Entry { k: i32, v: i32 }, + #[error(fmt = crate::util::octal)] + I16(i16), + #[error(fmt = crate::util::octal::)] + I32 { n: i32 }, + #[error(fmt = core::fmt::Octal::fmt)] + I64(i64), + #[error("...{0}")] + Other(bool), + } + + assert("unit=", Error::Unit); + assert("pair=10:0", Error::Tuple(10, 0)); + assert("pair=10:0", Error::Entry { k: 10, v: 0 }); + assert("0o777", Error::I16(0o777)); + assert("0o777", Error::I32 { n: 0o777 }); + assert("777", Error::I64(0o777)); + assert("...false", Error::Other(false)); +} + +#[test] +fn test_fmt_path_inherited() { + #[derive(Error, Debug)] + #[error(fmt = crate::util::octal)] + pub enum Error { + I16(i16), + I32 { + n: i32, + }, + #[error(fmt = core::fmt::Octal::fmt)] + I64(i64), + #[error("...{0}")] + Other(bool), + } + + assert("0o777", Error::I16(0o777)); + assert("0o777", Error::I32 { n: 0o777 }); + assert("777", Error::I64(0o777)); + assert("...false", Error::Other(false)); +} diff --git a/tests/ui/concat-display.stderr b/tests/ui/concat-display.stderr index d92e635..9255488 100644 --- a/tests/ui/concat-display.stderr +++ b/tests/ui/concat-display.stderr @@ -1,4 +1,4 @@ -error: expected string literal or `transparent` +error: expected one of: string literal, `transparent`, `fmt` --> tests/ui/concat-display.rs:8:17 | 8 | #[error(concat!("invalid ", $what))] diff --git a/tests/ui/duplicate-fmt.rs b/tests/ui/duplicate-fmt.rs index cb3d678..32f7a23 100644 --- a/tests/ui/duplicate-fmt.rs +++ b/tests/ui/duplicate-fmt.rs @@ -5,4 +5,19 @@ use thiserror::Error; #[error("...")] pub struct Error; +#[derive(Error, Debug)] +#[error(fmt = core::fmt::Octal::fmt)] +#[error(fmt = core::fmt::LowerHex::fmt)] +pub enum FmtFmt {} + +#[derive(Error, Debug)] +#[error(fmt = core::fmt::Octal::fmt)] +#[error(transparent)] +pub enum FmtTransparent {} + +#[derive(Error, Debug)] +#[error(fmt = core::fmt::Octal::fmt)] +#[error("...")] +pub enum FmtDisplay {} + fn main() {} diff --git a/tests/ui/duplicate-fmt.stderr b/tests/ui/duplicate-fmt.stderr index 532b16b..a6c9932 100644 --- a/tests/ui/duplicate-fmt.stderr +++ b/tests/ui/duplicate-fmt.stderr @@ -3,3 +3,21 @@ error: only one #[error(...)] attribute is allowed | 5 | #[error("...")] | ^^^^^^^^^^^^^^^ + +error: duplicate #[error(fmt = ...)] attribute + --> tests/ui/duplicate-fmt.rs:10:1 + | +10 | #[error(fmt = core::fmt::LowerHex::fmt)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: cannot have both #[error(transparent)] and #[error(fmt = ...)] + --> tests/ui/duplicate-fmt.rs:14:1 + | +14 | #[error(fmt = core::fmt::Octal::fmt)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error: cannot have both #[error(fmt = ...)] and a format arguments attribute + --> tests/ui/duplicate-fmt.rs:20:1 + | +20 | #[error("...")] + | ^^^^^^^^^^^^^^^ diff --git a/tests/ui/struct-with-fmt.rs b/tests/ui/struct-with-fmt.rs new file mode 100644 index 0000000..73bf79f --- /dev/null +++ b/tests/ui/struct-with-fmt.rs @@ -0,0 +1,7 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error(fmt = core::fmt::Octal::fmt)] +pub struct Error(i32); + +fn main() {} diff --git a/tests/ui/struct-with-fmt.stderr b/tests/ui/struct-with-fmt.stderr new file mode 100644 index 0000000..00463be --- /dev/null +++ b/tests/ui/struct-with-fmt.stderr @@ -0,0 +1,5 @@ +error: #[error(fmt = ...)] is only supported in enums; for a struct, handwrite your own Display impl + --> tests/ui/struct-with-fmt.rs:4:1 + | +4 | #[error(fmt = core::fmt::Octal::fmt)] + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ From 831138002bfaf886f48e117d78d60cc57f5dbe5c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 17:35:13 -0500 Subject: [PATCH 065/131] Ignore trivially_copy_pass_by_ref pedantic clippy lint in test warning: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte) --> tests/test_display.rs:388:16 | 388 | fn pair(k: &i32, v: &i32, formatter: &mut fmt::Formatter) -> fmt::Result { | ^^^^ help: consider passing by value instead: `i32` | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref = note: `-W clippy::trivially-copy-pass-by-ref` implied by `-W clippy::pedantic` = help: to override `-W clippy::pedantic` add `#[allow(clippy::trivially_copy_pass_by_ref)]` warning: this argument (4 byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte) --> tests/test_display.rs:388:25 | 388 | fn pair(k: &i32, v: &i32, formatter: &mut fmt::Formatter) -> fmt::Result { | ^^^^ help: consider passing by value instead: `i32` | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref --- tests/test_display.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_display.rs b/tests/test_display.rs index ec4170d..1904eae 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -1,6 +1,7 @@ #![allow( clippy::needless_lifetimes, clippy::needless_raw_string_hashes, + clippy::trivially_copy_pass_by_ref, clippy::uninlined_format_args )] From fa2ba3a53137e125ca1254e44a03e9901d43ac4a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 19:06:32 -0500 Subject: [PATCH 066/131] Perform imports from thiserror through absolute path --- impl/src/expand.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index f6f45f9..f2cb403 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -91,7 +91,7 @@ fn impl_struct(input: Struct) -> TokenStream { let source_method = source_body.map(|body| { quote! { fn source(&self) -> ::core::option::Option<&(dyn std::error::Error + 'static)> { - use thiserror::__private::AsDynError as _; + use ::thiserror::__private::AsDynError as _; #body } } @@ -127,7 +127,7 @@ fn impl_struct(input: Struct) -> TokenStream { }) }; quote! { - use thiserror::__private::ThiserrorProvide as _; + use ::thiserror::__private::ThiserrorProvide as _; #source_provide #self_provide } @@ -273,7 +273,7 @@ fn impl_enum(input: Enum) -> TokenStream { }); Some(quote! { fn source(&self) -> ::core::option::Option<&(dyn std::error::Error + 'static)> { - use thiserror::__private::AsDynError as _; + use ::thiserror::__private::AsDynError as _; #[allow(deprecated)] match self { #(#arms)* @@ -323,7 +323,7 @@ fn impl_enum(input: Enum) -> TokenStream { #source: #varsource, .. } => { - use thiserror::__private::ThiserrorProvide as _; + use ::thiserror::__private::ThiserrorProvide as _; #source_provide #self_provide } @@ -347,7 +347,7 @@ fn impl_enum(input: Enum) -> TokenStream { }; quote! { #ty::#ident {#backtrace: #varsource, ..} => { - use thiserror::__private::ThiserrorProvide as _; + use ::thiserror::__private::ThiserrorProvide as _; #source_provide } } @@ -510,7 +510,7 @@ fn fields_pat(fields: &[Field]) -> TokenStream { fn use_as_display(needs_as_display: bool) -> Option { if needs_as_display { Some(quote! { - use thiserror::__private::AsDisplay as _; + use ::thiserror::__private::AsDisplay as _; }) } else { None From 2f92680b5f7a3f100740f584d0dd220d881d61b4 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 19:10:14 -0500 Subject: [PATCH 067/131] Access all std types through absolute path --- impl/src/expand.rs | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index f2cb403..7788a7a 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -37,7 +37,7 @@ fn fallback(input: &DeriveInput, error: syn::Error) -> TokenStream { #[allow(unused_qualifications)] #[automatically_derived] - impl #impl_generics std::error::Error for #ty #ty_generics #where_clause + impl #impl_generics ::std::error::Error for #ty #ty_generics #where_clause where // Work around trivial bounds being unstable. // https://github.com/rust-lang/rust/issues/48214 @@ -62,17 +62,17 @@ fn impl_struct(input: Struct) -> TokenStream { let source_body = if let Some(transparent_attr) = &input.attrs.transparent { let only_field = &input.fields[0]; if only_field.contains_generic { - error_inferred_bounds.insert(only_field.ty, quote!(std::error::Error)); + error_inferred_bounds.insert(only_field.ty, quote!(::std::error::Error)); } let member = &only_field.member; Some(quote_spanned! {transparent_attr.span=> - std::error::Error::source(self.#member.as_dyn_error()) + ::std::error::Error::source(self.#member.as_dyn_error()) }) } else if let Some(source_field) = input.source_field() { let source = &source_field.member; if source_field.contains_generic { let ty = unoptional_type(source_field.ty); - error_inferred_bounds.insert(ty, quote!(std::error::Error + 'static)); + error_inferred_bounds.insert(ty, quote!(::std::error::Error + 'static)); } let asref = if type_is_option(source_field.ty) { Some(quote_spanned!(source.span()=> .as_ref()?)) @@ -90,7 +90,7 @@ fn impl_struct(input: Struct) -> TokenStream { }; let source_method = source_body.map(|body| { quote! { - fn source(&self) -> ::core::option::Option<&(dyn std::error::Error + 'static)> { + fn source(&self) -> ::core::option::Option<&(dyn ::std::error::Error + 'static)> { use ::thiserror::__private::AsDynError as _; #body } @@ -118,12 +118,12 @@ fn impl_struct(input: Struct) -> TokenStream { } else if type_is_option(backtrace_field.ty) { Some(quote! { if let ::core::option::Option::Some(backtrace) = &self.#backtrace { - #request.provide_ref::(backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); } }) } else { Some(quote! { - #request.provide_ref::(&self.#backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(&self.#backtrace); }) }; quote! { @@ -134,16 +134,16 @@ fn impl_struct(input: Struct) -> TokenStream { } else if type_is_option(backtrace_field.ty) { quote! { if let ::core::option::Option::Some(backtrace) = &self.#backtrace { - #request.provide_ref::(backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); } } } else { quote! { - #request.provide_ref::(&self.#backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(&self.#backtrace); } }; quote! { - fn provide<'_request>(&'_request self, #request: &mut std::error::Request<'_request>) { + fn provide<'_request>(&'_request self, #request: &mut ::std::error::Request<'_request>) { #body } } @@ -218,7 +218,7 @@ fn impl_struct(input: Struct) -> TokenStream { quote! { #[allow(unused_qualifications)] #[automatically_derived] - impl #impl_generics std::error::Error for #ty #ty_generics #error_where_clause { + impl #impl_generics ::std::error::Error for #ty #ty_generics #error_where_clause { #source_method #provide_method } @@ -238,11 +238,11 @@ fn impl_enum(input: Enum) -> TokenStream { if let Some(transparent_attr) = &variant.attrs.transparent { let only_field = &variant.fields[0]; if only_field.contains_generic { - error_inferred_bounds.insert(only_field.ty, quote!(std::error::Error)); + error_inferred_bounds.insert(only_field.ty, quote!(::std::error::Error)); } let member = &only_field.member; let source = quote_spanned! {transparent_attr.span=> - std::error::Error::source(transparent.as_dyn_error()) + ::std::error::Error::source(transparent.as_dyn_error()) }; quote! { #ty::#ident {#member: transparent} => #source, @@ -251,7 +251,7 @@ fn impl_enum(input: Enum) -> TokenStream { let source = &source_field.member; if source_field.contains_generic { let ty = unoptional_type(source_field.ty); - error_inferred_bounds.insert(ty, quote!(std::error::Error + 'static)); + error_inferred_bounds.insert(ty, quote!(::std::error::Error + 'static)); } let asref = if type_is_option(source_field.ty) { Some(quote_spanned!(source.span()=> .as_ref()?)) @@ -272,7 +272,7 @@ fn impl_enum(input: Enum) -> TokenStream { } }); Some(quote! { - fn source(&self) -> ::core::option::Option<&(dyn std::error::Error + 'static)> { + fn source(&self) -> ::core::option::Option<&(dyn ::std::error::Error + 'static)> { use ::thiserror::__private::AsDynError as _; #[allow(deprecated)] match self { @@ -309,12 +309,12 @@ fn impl_enum(input: Enum) -> TokenStream { let self_provide = if type_is_option(backtrace_field.ty) { quote! { if let ::core::option::Option::Some(backtrace) = backtrace { - #request.provide_ref::(backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); } } } else { quote! { - #request.provide_ref::(backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); } }; quote! { @@ -357,12 +357,12 @@ fn impl_enum(input: Enum) -> TokenStream { let body = if type_is_option(backtrace_field.ty) { quote! { if let ::core::option::Option::Some(backtrace) = backtrace { - #request.provide_ref::(backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); } } } else { quote! { - #request.provide_ref::(backtrace); + #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); } }; quote! { @@ -377,7 +377,7 @@ fn impl_enum(input: Enum) -> TokenStream { } }); Some(quote! { - fn provide<'_request>(&'_request self, #request: &mut std::error::Request<'_request>) { + fn provide<'_request>(&'_request self, #request: &mut ::std::error::Request<'_request>) { #[allow(deprecated)] match self { #(#arms)* @@ -483,7 +483,7 @@ fn impl_enum(input: Enum) -> TokenStream { quote! { #[allow(unused_qualifications)] #[automatically_derived] - impl #impl_generics std::error::Error for #ty #ty_generics #error_where_clause { + impl #impl_generics ::std::error::Error for #ty #ty_generics #error_where_clause { #source_method #provide_method } @@ -532,11 +532,11 @@ fn from_initializer( let backtrace_member = &backtrace_field.member; if type_is_option(backtrace_field.ty) { quote! { - #backtrace_member: ::core::option::Option::Some(std::backtrace::Backtrace::capture()), + #backtrace_member: ::core::option::Option::Some(::std::backtrace::Backtrace::capture()), } } else { quote! { - #backtrace_member: ::core::convert::From::from(std::backtrace::Backtrace::capture()), + #backtrace_member: ::core::convert::From::from(::std::backtrace::Backtrace::capture()), } } }); From e0e994314b273f9410243f692ab0925ca039ba3a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 19:21:03 -0500 Subject: [PATCH 068/131] Access Error trait exclusively through ::thiserror --- impl/src/expand.rs | 22 +++++++++++----------- src/lib.rs | 2 ++ 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 7788a7a..78fbb5f 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -37,7 +37,7 @@ fn fallback(input: &DeriveInput, error: syn::Error) -> TokenStream { #[allow(unused_qualifications)] #[automatically_derived] - impl #impl_generics ::std::error::Error for #ty #ty_generics #where_clause + 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 @@ -62,17 +62,17 @@ fn impl_struct(input: Struct) -> TokenStream { let source_body = if let Some(transparent_attr) = &input.attrs.transparent { let only_field = &input.fields[0]; if only_field.contains_generic { - error_inferred_bounds.insert(only_field.ty, quote!(::std::error::Error)); + error_inferred_bounds.insert(only_field.ty, quote!(::thiserror::__private::Error)); } let member = &only_field.member; Some(quote_spanned! {transparent_attr.span=> - ::std::error::Error::source(self.#member.as_dyn_error()) + ::thiserror::__private::Error::source(self.#member.as_dyn_error()) }) } else if let Some(source_field) = input.source_field() { let source = &source_field.member; if source_field.contains_generic { let ty = unoptional_type(source_field.ty); - error_inferred_bounds.insert(ty, quote!(::std::error::Error + 'static)); + error_inferred_bounds.insert(ty, quote!(::thiserror::__private::Error + 'static)); } let asref = if type_is_option(source_field.ty) { Some(quote_spanned!(source.span()=> .as_ref()?)) @@ -90,7 +90,7 @@ fn impl_struct(input: Struct) -> TokenStream { }; let source_method = source_body.map(|body| { quote! { - fn source(&self) -> ::core::option::Option<&(dyn ::std::error::Error + 'static)> { + fn source(&self) -> ::core::option::Option<&(dyn ::thiserror::__private::Error + 'static)> { use ::thiserror::__private::AsDynError as _; #body } @@ -218,7 +218,7 @@ fn impl_struct(input: Struct) -> TokenStream { quote! { #[allow(unused_qualifications)] #[automatically_derived] - impl #impl_generics ::std::error::Error for #ty #ty_generics #error_where_clause { + impl #impl_generics ::thiserror::__private::Error for #ty #ty_generics #error_where_clause { #source_method #provide_method } @@ -238,11 +238,11 @@ fn impl_enum(input: Enum) -> TokenStream { if let Some(transparent_attr) = &variant.attrs.transparent { let only_field = &variant.fields[0]; if only_field.contains_generic { - error_inferred_bounds.insert(only_field.ty, quote!(::std::error::Error)); + error_inferred_bounds.insert(only_field.ty, quote!(::thiserror::__private::Error)); } let member = &only_field.member; let source = quote_spanned! {transparent_attr.span=> - ::std::error::Error::source(transparent.as_dyn_error()) + ::thiserror::__private::Error::source(transparent.as_dyn_error()) }; quote! { #ty::#ident {#member: transparent} => #source, @@ -251,7 +251,7 @@ fn impl_enum(input: Enum) -> TokenStream { let source = &source_field.member; if source_field.contains_generic { let ty = unoptional_type(source_field.ty); - error_inferred_bounds.insert(ty, quote!(::std::error::Error + 'static)); + error_inferred_bounds.insert(ty, quote!(::thiserror::__private::Error + 'static)); } let asref = if type_is_option(source_field.ty) { Some(quote_spanned!(source.span()=> .as_ref()?)) @@ -272,7 +272,7 @@ fn impl_enum(input: Enum) -> TokenStream { } }); Some(quote! { - fn source(&self) -> ::core::option::Option<&(dyn ::std::error::Error + 'static)> { + fn source(&self) -> ::core::option::Option<&(dyn ::thiserror::__private::Error + 'static)> { use ::thiserror::__private::AsDynError as _; #[allow(deprecated)] match self { @@ -483,7 +483,7 @@ fn impl_enum(input: Enum) -> TokenStream { quote! { #[allow(unused_qualifications)] #[automatically_derived] - impl #impl_generics ::std::error::Error for #ty #ty_generics #error_where_clause { + impl #impl_generics ::thiserror::__private::Error for #ty #ty_generics #error_where_clause { #source_method #provide_method } diff --git a/src/lib.rs b/src/lib.rs index e8b014c..26dbdb1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -287,4 +287,6 @@ pub mod __private { #[cfg(error_generic_member_access)] #[doc(hidden)] pub use crate::provide::ThiserrorProvide; + #[doc(hidden)] + pub use std::error::Error; } From 2e99c515f31e99b96c6a4b91ebefe8c798333ece Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 19:26:24 -0500 Subject: [PATCH 069/131] Drop Provider API support in pre-1.81 nightlies --- build/probe.rs | 2 +- impl/src/expand.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/build/probe.rs b/build/probe.rs index faf25c5..5fbadcb 100644 --- a/build/probe.rs +++ b/build/probe.rs @@ -4,8 +4,8 @@ #![feature(error_generic_member_access)] +use core::error::{Error, Request}; use core::fmt::{self, Debug, Display}; -use std::error::{Error, Request}; struct MyError(Thing); struct Thing; diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 78fbb5f..bfa1b50 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -143,7 +143,7 @@ fn impl_struct(input: Struct) -> TokenStream { } }; quote! { - fn provide<'_request>(&'_request self, #request: &mut ::std::error::Request<'_request>) { + fn provide<'_request>(&'_request self, #request: &mut ::core::error::Request<'_request>) { #body } } @@ -377,7 +377,7 @@ fn impl_enum(input: Enum) -> TokenStream { } }); Some(quote! { - fn provide<'_request>(&'_request self, #request: &mut ::std::error::Request<'_request>) { + fn provide<'_request>(&'_request self, #request: &mut ::core::error::Request<'_request>) { #[allow(deprecated)] match self { #(#arms)* From d6d896df4c63fcb7b7c34aad5f5f049bf6cfab3b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 20:51:28 -0500 Subject: [PATCH 070/131] Access Backtrace exclusively through ::thiserror --- build.rs | 24 ++++++++++++++++++++++++ impl/src/expand.rs | 20 ++++++++++---------- src/lib.rs | 3 +++ 3 files changed, 37 insertions(+), 10 deletions(-) diff --git a/build.rs b/build.rs index 4b40e9d..8495ef3 100644 --- a/build.rs +++ b/build.rs @@ -5,12 +5,14 @@ use std::io::ErrorKind; use std::iter; use std::path::Path; use std::process::{self, Command, Stdio}; +use std::str; fn main() { println!("cargo:rerun-if-changed=build/probe.rs"); println!("cargo:rustc-check-cfg=cfg(error_generic_member_access)"); println!("cargo:rustc-check-cfg=cfg(thiserror_nightly_testing)"); + println!("cargo:rustc-check-cfg=cfg(thiserror_no_backtrace_type)"); let error_generic_member_access; let consider_rustc_bootstrap; @@ -54,6 +56,17 @@ fn main() { if consider_rustc_bootstrap { println!("cargo:rerun-if-env-changed=RUSTC_BOOTSTRAP"); } + + let rustc = match rustc_minor_version() { + Some(rustc) => rustc, + None => return, + }; + + // std::backtrace::Backtrace stabilized in Rust 1.65 + // https://blog.rust-lang.org/2022/11/03/Rust-1.65.0.html#stabilized-apis + if rustc < 65 { + println!("cargo:rustc-cfg=thiserror_no_backtrace_type"); + } } fn compile_probe(rustc_bootstrap: bool) -> bool { @@ -135,6 +148,17 @@ fn compile_probe(rustc_bootstrap: bool) -> bool { success } +fn rustc_minor_version() -> Option { + let rustc = cargo_env_var("RUSTC"); + let output = Command::new(rustc).arg("--version").output().ok()?; + let version = str::from_utf8(&output.stdout).ok()?; + let mut pieces = version.split('.'); + if pieces.next() != Some("rustc 1") { + return None; + } + pieces.next()?.parse().ok() +} + fn cargo_env_var(key: &str) -> OsString { env::var_os(key).unwrap_or_else(|| { eprintln!("Environment variable ${key} is not set during execution of build script"); diff --git a/impl/src/expand.rs b/impl/src/expand.rs index bfa1b50..e172af9 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -118,12 +118,12 @@ fn impl_struct(input: Struct) -> TokenStream { } else if type_is_option(backtrace_field.ty) { Some(quote! { if let ::core::option::Option::Some(backtrace) = &self.#backtrace { - #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(backtrace); } }) } else { Some(quote! { - #request.provide_ref::<::std::backtrace::Backtrace>(&self.#backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(&self.#backtrace); }) }; quote! { @@ -134,12 +134,12 @@ fn impl_struct(input: Struct) -> TokenStream { } else if type_is_option(backtrace_field.ty) { quote! { if let ::core::option::Option::Some(backtrace) = &self.#backtrace { - #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(backtrace); } } } else { quote! { - #request.provide_ref::<::std::backtrace::Backtrace>(&self.#backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(&self.#backtrace); } }; quote! { @@ -309,12 +309,12 @@ fn impl_enum(input: Enum) -> TokenStream { let self_provide = if type_is_option(backtrace_field.ty) { quote! { if let ::core::option::Option::Some(backtrace) = backtrace { - #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(backtrace); } } } else { quote! { - #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(backtrace); } }; quote! { @@ -357,12 +357,12 @@ fn impl_enum(input: Enum) -> TokenStream { let body = if type_is_option(backtrace_field.ty) { quote! { if let ::core::option::Option::Some(backtrace) = backtrace { - #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(backtrace); } } } else { quote! { - #request.provide_ref::<::std::backtrace::Backtrace>(backtrace); + #request.provide_ref::<::thiserror::__private::Backtrace>(backtrace); } }; quote! { @@ -532,11 +532,11 @@ fn from_initializer( let backtrace_member = &backtrace_field.member; if type_is_option(backtrace_field.ty) { quote! { - #backtrace_member: ::core::option::Option::Some(::std::backtrace::Backtrace::capture()), + #backtrace_member: ::core::option::Option::Some(::thiserror::__private::Backtrace::capture()), } } else { quote! { - #backtrace_member: ::core::convert::From::from(::std::backtrace::Backtrace::capture()), + #backtrace_member: ::core::convert::From::from(::thiserror::__private::Backtrace::capture()), } } }); diff --git a/src/lib.rs b/src/lib.rs index 26dbdb1..17975e8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -287,6 +287,9 @@ pub mod __private { #[cfg(error_generic_member_access)] #[doc(hidden)] pub use crate::provide::ThiserrorProvide; + #[cfg(not(thiserror_no_backtrace_type))] + #[doc(hidden)] + pub use std::backtrace::Backtrace; #[doc(hidden)] pub use std::error::Error; } From d8ed5fbc2f7476430ff8e50b37f466638cd732f3 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 19:43:34 -0500 Subject: [PATCH 071/131] Allow disabling std dependency on 1.81+ --- .github/workflows/ci.yml | 6 +++-- Cargo.toml | 18 ++++++++++++- build.rs | 9 ++++++- build/probe.rs | 1 + src/aserror.rs | 2 +- src/display.rs | 35 ++++++++++++++++++++++++ src/lib.rs | 12 ++++++--- src/provide.rs | 2 +- tests/no-std/Cargo.toml | 12 +++++++++ tests/no-std/test.rs | 58 ++++++++++++++++++++++++++++++++++++++++ 10 files changed, 146 insertions(+), 9 deletions(-) create mode 100644 tests/no-std/Cargo.toml create mode 100644 tests/no-std/test.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a2b6200..6f4f001 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,7 +24,7 @@ jobs: strategy: fail-fast: false matrix: - rust: [nightly, beta, stable, 1.70.0] + rust: [nightly, beta, stable, 1.81.0, 1.70.0] timeout-minutes: 45 steps: - uses: actions/checkout@v4 @@ -38,7 +38,9 @@ jobs: - name: Enable nightly-only tests run: echo RUSTFLAGS=${RUSTFLAGS}\ --cfg=thiserror_nightly_testing >> $GITHUB_ENV if: matrix.rust == 'nightly' - - run: cargo test --all + - 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' - uses: actions/upload-artifact@v4 if: matrix.rust == 'nightly' && always() with: diff --git a/Cargo.toml b/Cargo.toml index 23f3609..dd8f11c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,6 +11,22 @@ license = "MIT OR Apache-2.0" repository = "https://github.com/dtolnay/thiserror" rust-version = "1.61" +[features] +default = ["std"] + +# Std feature enables support for formatting std::path::{Path, PathBuf} +# conveniently in an error message. +# +# #[derive(Error, Debug)] +# #[error("failed to create configuration file {path}")] +# pub struct MyError { +# pub path: PathBuf, +# pub source: std::io::Error, +# } +# +# Without std, this would need to be written #[error("... {}", path.display())]. +std = [] + [dependencies] thiserror-impl = { version = "=1.0.68", path = "impl" } @@ -21,7 +37,7 @@ rustversion = "1.0.13" trybuild = { version = "1.0.81", features = ["diff"] } [workspace] -members = ["impl"] +members = ["impl", "tests/no-std"] [package.metadata.docs.rs] targets = ["x86_64-unknown-linux-gnu"] diff --git a/build.rs b/build.rs index 8495ef3..5d795e4 100644 --- a/build.rs +++ b/build.rs @@ -57,7 +57,14 @@ fn main() { println!("cargo:rerun-if-env-changed=RUSTC_BOOTSTRAP"); } - let rustc = match rustc_minor_version() { + // core::error::Error stabilized in Rust 1.81 + // https://blog.rust-lang.org/2024/09/05/Rust-1.81.0.html#coreerrorerror + let rustc = rustc_minor_version(); + if cfg!(not(feature = "std")) && rustc.map_or(false, |rustc| rustc < 81) { + println!("cargo:rustc-cfg=feature=\"std\""); + } + + let rustc = match rustc { Some(rustc) => rustc, None => return, }; diff --git a/build/probe.rs b/build/probe.rs index 5fbadcb..ee126d4 100644 --- a/build/probe.rs +++ b/build/probe.rs @@ -2,6 +2,7 @@ // member access API. If the current toolchain is able to compile it, then // thiserror is able to provide backtrace support. +#![no_std] #![feature(error_generic_member_access)] use core::error::{Error, Request}; diff --git a/src/aserror.rs b/src/aserror.rs index 1bced57..d66463a 100644 --- a/src/aserror.rs +++ b/src/aserror.rs @@ -1,5 +1,5 @@ +use core::error::Error; use core::panic::UnwindSafe; -use std::error::Error; #[doc(hidden)] pub trait AsDynError<'a>: Sealed { diff --git a/src/display.rs b/src/display.rs index 7a62ae2..7ccdd81 100644 --- a/src/display.rs +++ b/src/display.rs @@ -1,4 +1,5 @@ use core::fmt::Display; +#[cfg(feature = "std")] use std::path::{self, Path, PathBuf}; #[doc(hidden)] @@ -21,6 +22,7 @@ where } } +#[cfg(feature = "std")] impl<'a> AsDisplay<'a> for Path { type Target = path::Display<'a>; @@ -30,6 +32,7 @@ impl<'a> AsDisplay<'a> for Path { } } +#[cfg(feature = "std")] impl<'a> AsDisplay<'a> for PathBuf { type Target = path::Display<'a>; @@ -42,5 +45,37 @@ impl<'a> AsDisplay<'a> for PathBuf { #[doc(hidden)] pub trait Sealed {} impl Sealed for &T {} +#[cfg(feature = "std")] impl Sealed for Path {} +#[cfg(feature = "std")] impl Sealed for PathBuf {} + +// Add a synthetic second impl of AsDisplay to prevent the "single applicable +// impl" rule from making too weird inference decision based on the single impl +// for &T, which could lead to code that compiles with thiserror's std feature +// off but breaks under feature unification when std is turned on by an +// unrelated crate. +#[cfg(not(feature = "std"))] +mod placeholder { + use super::{AsDisplay, Sealed}; + use core::fmt::{self, Display}; + + pub struct Placeholder; + + impl<'a> AsDisplay<'a> for Placeholder { + type Target = Self; + + #[inline] + fn as_display(&'a self) -> Self::Target { + Placeholder + } + } + + impl Display for Placeholder { + fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result { + unreachable!() + } + } + + impl Sealed for Placeholder {} +} diff --git a/src/lib.rs b/src/lib.rs index 17975e8..fec22cd 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -258,6 +258,7 @@ //! //! [`anyhow`]: https://github.com/dtolnay/anyhow +#![no_std] #![doc(html_root_url = "https://docs.rs/thiserror/1.0.68")] #![allow( clippy::module_name_repetitions, @@ -270,6 +271,11 @@ #[cfg(all(thiserror_nightly_testing, not(error_generic_member_access)))] compile_error!("Build script probe failed to compile."); +#[cfg(feature = "std")] +extern crate std; +#[cfg(feature = "std")] +extern crate std as core; + mod aserror; mod display; #[cfg(error_generic_member_access)] @@ -287,9 +293,9 @@ pub mod __private { #[cfg(error_generic_member_access)] #[doc(hidden)] pub use crate::provide::ThiserrorProvide; - #[cfg(not(thiserror_no_backtrace_type))] + #[doc(hidden)] + pub use core::error::Error; + #[cfg(all(feature = "std", not(thiserror_no_backtrace_type)))] #[doc(hidden)] pub use std::backtrace::Backtrace; - #[doc(hidden)] - pub use std::error::Error; } diff --git a/src/provide.rs b/src/provide.rs index 7b4e922..4b2f06a 100644 --- a/src/provide.rs +++ b/src/provide.rs @@ -1,4 +1,4 @@ -use std::error::{Error, Request}; +use core::error::{Error, Request}; #[doc(hidden)] pub trait ThiserrorProvide: Sealed { diff --git a/tests/no-std/Cargo.toml b/tests/no-std/Cargo.toml new file mode 100644 index 0000000..8b03d2f --- /dev/null +++ b/tests/no-std/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "thiserror_no_std_test" +version = "0.0.0" +authors = ["David Tolnay "] +edition = "2021" +publish = false + +[lib] +path = "test.rs" + +[dependencies] +thiserror = { path = "../..", default-features = false } diff --git a/tests/no-std/test.rs b/tests/no-std/test.rs new file mode 100644 index 0000000..da7899c --- /dev/null +++ b/tests/no-std/test.rs @@ -0,0 +1,58 @@ +#![no_std] + +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum Error { + #[error("Error::E")] + E(#[from] SourceError), +} + +#[derive(Error, Debug)] +#[error("SourceError {field}")] +pub struct SourceError { + pub field: i32, +} + +#[cfg(test)] +mod tests { + use crate::{Error, SourceError}; + use core::error::Error as _; + use core::fmt::{self, Write}; + use core::mem; + + struct Buf<'a>(&'a mut [u8]); + + impl Write for Buf<'_> { + fn write_str(&mut self, s: &str) -> fmt::Result { + if s.len() <= self.0.len() { + let (out, rest) = mem::take(&mut self.0).split_at_mut(s.len()); + out.copy_from_slice(s.as_bytes()); + self.0 = rest; + Ok(()) + } else { + Err(fmt::Error) + } + } + } + + #[test] + fn test() { + let source = SourceError { field: -1 }; + let error = Error::from(source); + + let source = error + .source() + .unwrap() + .downcast_ref::() + .unwrap(); + + let mut msg = [b'~'; 17]; + write!(Buf(&mut msg), "{error}").unwrap(); + assert_eq!(msg, *b"Error::E~~~~~~~~~"); + + let mut msg = [b'~'; 17]; + write!(Buf(&mut msg), "{source}").unwrap(); + assert_eq!(msg, *b"SourceError -1~~~"); + } +} From 6097d61b5878c4eca29be1cb0d7f96268309dd84 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 5 Nov 2024 21:50:34 -0500 Subject: [PATCH 072/131] Release 2.0.0 --- Cargo.toml | 4 ++-- README.md | 2 +- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index dd8f11c..cfd7046 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "1.0.68" +version = "2.0.0" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=1.0.68", path = "impl" } +thiserror-impl = { version = "=2.0.0", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/README.md b/README.md index 5082f95..6519e04 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ This library provides a convenient derive macro for the standard library's ```toml [dependencies] -thiserror = "1.0" +thiserror = "2" ``` *Compiler support: requires rustc 1.61+* diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 933831e..2f92764 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "1.0.68" +version = "2.0.0" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index fec22cd..1489fc6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/1.0.68")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.0")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 8e8e27376c060f5e0e8beb8c0827fe752d021890 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 12:18:53 -0500 Subject: [PATCH 073/131] Add test of dynamically sized error type error[E0599]: the method `as_display` exists for reference `&str`, but its trait bounds were not satisfied --> tests/test_path.rs:26:9 | 26 | #[error("{tail}")] | ^^^^^^^^ method cannot be called on `&str` due to unsatisfied trait bounds | = note: the following trait bounds were not satisfied: `str: Sized` which is required by `&str: AsDisplay<'_>` --- tests/test_path.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tests/test_path.rs b/tests/test_path.rs index f054077..16881ae 100644 --- a/tests/test_path.rs +++ b/tests/test_path.rs @@ -22,6 +22,13 @@ enum EnumPathBuf { Read(PathBuf), } +#[derive(Error, Debug)] +#[error("{tail}")] +pub struct UnsizedError { + pub head: i32, + pub tail: str, +} + fn assert(expected: &str, value: T) { assert_eq!(expected, value.to_string()); } From 24c04daea901b7a426db8fca2c743d0253986ab3 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 12:19:52 -0500 Subject: [PATCH 074/131] Support dynamically sized field in error --- src/display.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/display.rs b/src/display.rs index 7ccdd81..7b2bf1c 100644 --- a/src/display.rs +++ b/src/display.rs @@ -13,7 +13,7 @@ pub trait AsDisplay<'a>: Sealed { impl<'a, T> AsDisplay<'a> for &T where - T: Display + 'a, + T: Display + ?Sized + 'a, { type Target = &'a T; @@ -44,7 +44,7 @@ impl<'a> AsDisplay<'a> for PathBuf { #[doc(hidden)] pub trait Sealed {} -impl Sealed for &T {} +impl Sealed for &T {} #[cfg(feature = "std")] impl Sealed for Path {} #[cfg(feature = "std")] From 1bb7e7aa78c3c41991b9525e3c85b7481acb2a51 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 12:30:13 -0500 Subject: [PATCH 075/131] Check invalid Named member references before producing MemberUnraw --- impl/src/fmt.rs | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index baff7e0..36300e5 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -73,19 +73,25 @@ impl Display<'_> { if read.starts_with("r#") { continue; } - let ident = Ident::new(take_ident(&mut read), span); - MemberUnraw::Named(IdentUnraw::new(ident)) + let repr = take_ident(&mut read); + if repr == "_" { + // Invalid. Let rustc produce the diagnostic. + out += repr; + continue; + } + let ident = IdentUnraw::new(Ident::new(repr, span)); + if user_named_args.contains(&ident) { + // Refers to a named argument written by the user, not to field. + out += repr; + continue; + } + MemberUnraw::Named(ident) } _ => continue, }; let mut formatvar = match &member { MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("__field{}", index)), MemberUnraw::Named(ident) => { - if user_named_args.contains(ident) || ident == "_" { - // Refers to a named argument written by the user, not to field. - out += &ident.to_string(); - continue; - } IdentUnraw::new(format_ident!("__field_{}", ident.to_string())) } }; From fb8d3a7f448aa2db8e9bb13fae03c687f64d112b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 12:43:16 -0500 Subject: [PATCH 076/131] Add test using generic type with multiple bounds error[E0277]: the trait bound `T: UpperHex` is not satisfied --> tests/test_generics.rs:179:13 | 178 | #[derive(Error, Debug)] | ----- in this derive macro expansion 179 | #[error("0x{thing:x} 0x{thing:X}")] | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `UpperHex` is not implemented for `T` | = note: required for `&T` to implement `UpperHex` note: required by a bound in `core::fmt::rt::Argument::<'_>::new_upper_hex` --> $RUSTUP_HOME/toolchains/nightly-aarch64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/fmt/rt.rs:133:29 | 133 | pub fn new_upper_hex(x: &T) -> Argument<'_> { | ^^^^^^^^ required by this bound in `Argument::<'_>::new_upper_hex` = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info) --- tests/test_generics.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/tests/test_generics.rs b/tests/test_generics.rs index 4d49edf..36f1181 100644 --- a/tests/test_generics.rs +++ b/tests/test_generics.rs @@ -172,3 +172,15 @@ fn test_no_bound_on_named_fmt() { let error = Error { thing: DebugOnly }; assert_eq!(error.to_string(), "..."); } + +#[test] +fn test_multiple_bound() { + #[derive(Error, Debug)] + #[error("0x{thing:x} 0x{thing:X}")] + pub struct Error { + thing: T, + } + + let error = Error { thing: 0xFFi32 }; + assert_eq!(error.to_string(), "0xff 0xFF"); +} From 5948ee6ce45031a4520f7a6a345df36bf8a33be0 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 12:48:02 -0500 Subject: [PATCH 077/131] Support generic types that need multiple bounds --- impl/src/fmt.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 36300e5..6dfdccf 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -99,10 +99,6 @@ impl Display<'_> { formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); } out += &formatvar.to_string(); - if !macro_named_args.insert(member.clone()) { - // Already added to scope by a previous use. - continue; - } let local = formatvar.to_local(); let mut binding_value = ToTokens::into_token_stream(match &member { MemberUnraw::Unnamed(index) => format_ident!("_{}", index), @@ -142,7 +138,11 @@ impl Display<'_> { } ); } - bindings.push((local, binding_value)); + if macro_named_args.insert(member) { + bindings.push((local, binding_value)); + } else { + // Already added to bindings by a previous use. + } } out += read; From 337df1db6d815138b6040c414d1a8bf72a4bcb6a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 12:54:48 -0500 Subject: [PATCH 078/131] Move recursion checking out of bindings --- impl/src/attr.rs | 12 +++++++++++- impl/src/fmt.rs | 12 +++--------- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/impl/src/attr.rs b/impl/src/attr.rs index f98f731..7ad83e0 100644 --- a/impl/src/attr.rs +++ b/impl/src/attr.rs @@ -1,5 +1,5 @@ use proc_macro2::{Delimiter, Group, Literal, Punct, Spacing, Span, TokenStream, TokenTree}; -use quote::{format_ident, quote, ToTokens}; +use quote::{format_ident, quote, quote_spanned, ToTokens}; use std::collections::BTreeSet as Set; use syn::parse::discouraged::Speculative; use syn::parse::{End, ParseStream}; @@ -24,6 +24,7 @@ pub struct Display<'a> { pub args: TokenStream, pub requires_fmt_machinery: bool, pub has_bonus_display: bool, + pub infinite_recursive: bool, pub implied_bounds: Set<(usize, Trait)>, pub bindings: Vec<(Ident, TokenStream)>, } @@ -177,6 +178,7 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu args, requires_fmt_machinery, has_bonus_display: false, + infinite_recursive: false, implied_bounds: Set::new(), bindings: Vec::new(), }; @@ -299,6 +301,14 @@ fn parse_token_expr(input: ParseStream, mut begin_expr: bool) -> Result { fn to_tokens(&self, tokens: &mut TokenStream) { + if self.infinite_recursive { + let span = self.fmt.span(); + tokens.extend(quote_spanned! {span=> + #[warn(unconditional_recursion)] + fn _fmt() { _fmt() } + }); + } + let fmt = &self.fmt; let args = &self.args; diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 6dfdccf..ed7a6d3 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -31,6 +31,7 @@ impl Display<'_> { let mut read = fmt.as_str(); let mut out = String::new(); let mut has_bonus_display = false; + let mut infinite_recursive = false; let mut implied_bounds = BTreeSet::new(); let mut bindings = Vec::new(); let mut macro_named_args = HashSet::new(); @@ -129,15 +130,7 @@ impl Display<'_> { if let Some(&field) = member_index.get(&member) { implied_bounds.insert((field, bound)); } - if member == *"self" && bound == Trait::Display { - binding_value = quote_spanned!(member.span()=> - { - #[warn(unconditional_recursion)] - fn _fmt() { _fmt() } - #member - } - ); - } + infinite_recursive |= member == *"self" && bound == Trait::Display; if macro_named_args.insert(member) { bindings.push((local, binding_value)); } else { @@ -148,6 +141,7 @@ impl Display<'_> { out += read; self.fmt = LitStr::new(&out, self.fmt.span()); self.has_bonus_display = has_bonus_display; + self.infinite_recursive = infinite_recursive; self.implied_bounds = implied_bounds; self.bindings = bindings; Ok(()) From 24e7f87d0dd12ccd8eb79c744f40a0f54c71af72 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 13:07:02 -0500 Subject: [PATCH 079/131] Clean up formatvar identifier construction --- impl/src/fmt.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index ed7a6d3..69997b2 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -90,12 +90,10 @@ impl Display<'_> { } _ => continue, }; - let mut formatvar = match &member { - MemberUnraw::Unnamed(index) => IdentUnraw::new(format_ident!("__field{}", index)), - MemberUnraw::Named(ident) => { - IdentUnraw::new(format_ident!("__field_{}", ident.to_string())) - } - }; + let mut formatvar = IdentUnraw::new(match &member { + MemberUnraw::Unnamed(index) => format_ident!("__field{}", index), + MemberUnraw::Named(ident) => format_ident!("__field_{}", ident.to_string()), + }); while user_named_args.contains(&formatvar) { formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); } From 8a77dea3ae2f711c7f39a412b87ef99f60c9631b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 13:11:46 -0500 Subject: [PATCH 080/131] Parse trait bound before deciding name for local binding --- impl/src/fmt.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 69997b2..77b0dee 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -90,15 +90,6 @@ impl Display<'_> { } _ => continue, }; - let mut formatvar = IdentUnraw::new(match &member { - MemberUnraw::Unnamed(index) => format_ident!("__field{}", index), - MemberUnraw::Named(ident) => format_ident!("__field_{}", ident.to_string()), - }); - while user_named_args.contains(&formatvar) { - formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); - } - out += &formatvar.to_string(); - let local = formatvar.to_local(); let mut binding_value = ToTokens::into_token_stream(match &member { MemberUnraw::Unnamed(index) => format_ident!("_{}", index), MemberUnraw::Named(ident) => ident.to_local(), @@ -128,6 +119,15 @@ impl Display<'_> { if let Some(&field) = member_index.get(&member) { implied_bounds.insert((field, bound)); } + let mut formatvar = IdentUnraw::new(match &member { + MemberUnraw::Unnamed(index) => format_ident!("__field{}", index), + MemberUnraw::Named(ident) => format_ident!("__field_{}", ident.to_string()), + }); + while user_named_args.contains(&formatvar) { + formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); + } + out += &formatvar.to_string(); + let local = formatvar.to_local(); infinite_recursive |= member == *"self" && bound == Trait::Display; if macro_named_args.insert(member) { bindings.push((local, binding_value)); From f4d5c2a5de9a4ccbdda0bf63e5a626c5a251f760 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 13:16:48 -0500 Subject: [PATCH 081/131] Check infinite recursion as soon as Display bound is known --- impl/src/fmt.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 77b0dee..d2ab077 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -116,6 +116,7 @@ impl Display<'_> { Trait::Display } }; + infinite_recursive |= member == *"self" && bound == Trait::Display; if let Some(&field) = member_index.get(&member) { implied_bounds.insert((field, bound)); } @@ -128,7 +129,6 @@ impl Display<'_> { } out += &formatvar.to_string(); let local = formatvar.to_local(); - infinite_recursive |= member == *"self" && bound == Trait::Display; if macro_named_args.insert(member) { bindings.push((local, binding_value)); } else { From 3ee0a4dfdb00bec96c5c128b1d0fd3c8e4ebd923 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 13:15:57 -0500 Subject: [PATCH 082/131] Emit rebinding only for interpolations that refer to a field --- impl/src/fmt.rs | 13 +++++-------- impl/src/unraw.rs | 9 +++++++++ 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index d2ab077..d00ff5b 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -64,10 +64,6 @@ impl Display<'_> { Ok(index) => MemberUnraw::Unnamed(Index { index, span }), Err(_) => return Ok(()), }; - if !member_index.contains_key(&member) { - out += int; - continue; - } member } 'a'..='z' | 'A'..='Z' | '_' => { @@ -109,16 +105,17 @@ impl Display<'_> { Some('E') => Trait::UpperExp, Some(_) => Trait::Display, None => { - if member_index.contains_key(&member) { - has_bonus_display = true; - binding_value.extend(quote_spanned!(span=> .as_display())); - } + has_bonus_display = true; + binding_value.extend(quote_spanned!(span=> .as_display())); Trait::Display } }; infinite_recursive |= member == *"self" && bound == Trait::Display; if let Some(&field) = member_index.get(&member) { implied_bounds.insert((field, bound)); + } else { + out += &member.to_string(); + continue; } let mut formatvar = IdentUnraw::new(match &member { MemberUnraw::Unnamed(index) => format_ident!("__field{}", index), diff --git a/impl/src/unraw.rs b/impl/src/unraw.rs index c459b69..a232621 100644 --- a/impl/src/unraw.rs +++ b/impl/src/unraw.rs @@ -89,6 +89,15 @@ impl MemberUnraw { } } +impl Display for MemberUnraw { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + match self { + MemberUnraw::Named(this) => Display::fmt(this, formatter), + MemberUnraw::Unnamed(this) => Display::fmt(&this.index, formatter), + } + } +} + impl Eq for MemberUnraw {} impl PartialEq for MemberUnraw { From fb59da6f7bfbce2e1b586ac87eb79942365bb839 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 13:22:54 -0500 Subject: [PATCH 083/131] Resolve let_and_return clippy lint warning: returning the result of a `let` binding from a block --> impl/src/fmt.rs:67:21 | 63 | / let member = match int.parse::() { 64 | | Ok(index) => MemberUnraw::Unnamed(Index { index, span }), 65 | | Err(_) => return Ok(()), 66 | | }; | |______________________- unnecessary `let` binding 67 | member | ^^^^^^ | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return = note: `-W clippy::let-and-return` implied by `-W clippy::all` = help: to override `-W clippy::all` add `#[allow(clippy::let_and_return)]` help: return the expression directly | 63 ~ 64 ~ match int.parse::() { 65 + Ok(index) => MemberUnraw::Unnamed(Index { index, span }), 66 + Err(_) => return Ok(()), 67 + } | --- impl/src/fmt.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index d00ff5b..d369012 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -60,11 +60,10 @@ impl Display<'_> { return Err(Error::new_spanned(first_unnamed, msg)); } } - let member = match int.parse::() { + match int.parse::() { Ok(index) => MemberUnraw::Unnamed(Index { index, span }), Err(_) => return Ok(()), - }; - member + } } 'a'..='z' | 'A'..='Z' | '_' => { if read.starts_with("r#") { From 46586dde23efe3bf8d5c57f071f6ab1ec016fbd6 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 11:54:07 -0500 Subject: [PATCH 084/131] Add test that {:p} prints the right address thread 'test_pointer' panicked at tests/test_display.rs:265:5: assertion `left == right` failed left: "0x7fbbd7df10" right: "0x7fac000e30" --- tests/test_display.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/tests/test_display.rs b/tests/test_display.rs index 1904eae..1980d55 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -251,6 +251,20 @@ fn test_nested_tuple_field() { assert("0", Error(Inner(0))); } +#[test] +fn test_pointer() { + #[derive(Error, Debug)] + #[error("{field:p}")] + pub struct Struct { + field: Box, + } + + let s = Struct { + field: Box::new(-1), + }; + assert_eq!(s.to_string(), format!("{:p}", s.field)); +} + #[test] fn test_macro_rules() { // Regression test for https://github.com/dtolnay/thiserror/issues/86 From 16f8dc1bef54675283e8646bec62e9201cb35619 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 11:59:27 -0500 Subject: [PATCH 085/131] Wrap interpolated variables to forward Pointer correctly --- impl/src/fmt.rs | 13 +++++++---- src/lib.rs | 3 +++ src/var.rs | 61 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 72 insertions(+), 5 deletions(-) create mode 100644 src/var.rs diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index d369012..e69a7e9 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -3,7 +3,7 @@ use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; use crate::unraw::{IdentUnraw, MemberUnraw}; use proc_macro2::{Delimiter, TokenStream}; -use quote::{format_ident, quote, quote_spanned, ToTokens}; +use quote::{format_ident, quote, quote_spanned}; use std::collections::{BTreeSet, HashMap, HashSet}; use std::iter; use syn::ext::IdentExt; @@ -85,10 +85,11 @@ impl Display<'_> { } _ => continue, }; - let mut binding_value = ToTokens::into_token_stream(match &member { + let binding_value = match &member { MemberUnraw::Unnamed(index) => format_ident!("_{}", index), MemberUnraw::Named(ident) => ident.to_local(), - }); + }; + let mut wrapped_binding_value = quote!(::thiserror::__private::Var(#binding_value)); let end_spec = match read.find('}') { Some(end_spec) => end_spec, None => return Ok(()), @@ -105,7 +106,9 @@ impl Display<'_> { Some(_) => Trait::Display, None => { has_bonus_display = true; - binding_value.extend(quote_spanned!(span=> .as_display())); + wrapped_binding_value = quote_spanned! {span=> + #binding_value.as_display() + }; Trait::Display } }; @@ -126,7 +129,7 @@ impl Display<'_> { out += &formatvar.to_string(); let local = formatvar.to_local(); if macro_named_args.insert(member) { - bindings.push((local, binding_value)); + bindings.push((local, wrapped_binding_value)); } else { // Already added to bindings by a previous use. } diff --git a/src/lib.rs b/src/lib.rs index 1489fc6..ea5244d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -280,6 +280,7 @@ mod aserror; mod display; #[cfg(error_generic_member_access)] mod provide; +mod var; pub use thiserror_impl::*; @@ -294,6 +295,8 @@ pub mod __private { #[doc(hidden)] pub use crate::provide::ThiserrorProvide; #[doc(hidden)] + pub use crate::var::Var; + #[doc(hidden)] pub use core::error::Error; #[cfg(all(feature = "std", not(thiserror_no_backtrace_type)))] #[doc(hidden)] diff --git a/src/var.rs b/src/var.rs new file mode 100644 index 0000000..8643590 --- /dev/null +++ b/src/var.rs @@ -0,0 +1,61 @@ +use core::fmt::{ + self, Binary, Debug, Display, LowerExp, LowerHex, Octal, Pointer, UpperExp, UpperHex, +}; + +pub struct Var<'a, T: ?Sized>(pub &'a T); + +/// Pointer is the only one for which there is a difference in behavior between +/// `Var<'a, T>` vs `&'a T`. +impl<'a, T: Pointer + ?Sized> Pointer for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + Pointer::fmt(self.0, formatter) + } +} + +impl<'a, T: Binary + ?Sized> Binary for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + Binary::fmt(self.0, formatter) + } +} + +impl<'a, T: Debug + ?Sized> Debug for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + Debug::fmt(self.0, formatter) + } +} + +impl<'a, T: Display + ?Sized> Display for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + Display::fmt(self.0, formatter) + } +} + +impl<'a, T: LowerExp + ?Sized> LowerExp for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + LowerExp::fmt(self.0, formatter) + } +} + +impl<'a, T: LowerHex + ?Sized> LowerHex for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + LowerHex::fmt(self.0, formatter) + } +} + +impl<'a, T: Octal + ?Sized> Octal for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + Octal::fmt(self.0, formatter) + } +} + +impl<'a, T: UpperExp + ?Sized> UpperExp for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + UpperExp::fmt(self.0, formatter) + } +} + +impl<'a, T: UpperHex + ?Sized> UpperHex for Var<'a, T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + UpperHex::fmt(self.0, formatter) + } +} From 4066d537a31943c359f32e572e529bd1e5310ddc Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 14:25:42 -0500 Subject: [PATCH 086/131] Release 2.0.1 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index cfd7046..ddd289b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.0" +version = "2.0.1" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.0", path = "impl" } +thiserror-impl = { version = "=2.0.1", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 2f92764..c0d6ddd 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.0" +version = "2.0.1" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index ea5244d..88c2c8f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.0")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.1")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From a17d956bd86d6f1ae57763914d08fe1476e6581a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 14:29:08 -0500 Subject: [PATCH 087/131] Clean up unneeded var --- impl/src/fmt.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index e69a7e9..d958cbf 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -127,9 +127,8 @@ impl Display<'_> { formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); } out += &formatvar.to_string(); - let local = formatvar.to_local(); if macro_named_args.insert(member) { - bindings.push((local, wrapped_binding_value)); + bindings.push((formatvar.to_local(), wrapped_binding_value)); } else { // Already added to bindings by a previous use. } From 1048a35b26c8f215d48ff4c451f29b6089255a48 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 8 Nov 2024 21:45:50 -0500 Subject: [PATCH 088/131] Prevent upload-artifact step from causing CI failure This step has been failing way more than reasonable across my various repos. With the provided path, there will be 1 file uploaded Artifact name is valid! Root directory input is valid! Attempt 1 of 5 failed with error: Request timeout: /twirp/github.actions.results.api.v1.ArtifactService/CreateArtifact. Retrying request in 3000 ms... Attempt 2 of 5 failed with error: Request timeout: /twirp/github.actions.results.api.v1.ArtifactService/CreateArtifact. Retrying request in 6029 ms... Attempt 3 of 5 failed with error: Request timeout: /twirp/github.actions.results.api.v1.ArtifactService/CreateArtifact. Retrying request in 8270 ms... Attempt 4 of 5 failed with error: Request timeout: /twirp/github.actions.results.api.v1.ArtifactService/CreateArtifact. Retrying request in 12577 ms... Error: Failed to CreateArtifact: Failed to make request after 5 attempts: Request timeout: /twirp/github.actions.results.api.v1.ArtifactService/CreateArtifact --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6f4f001..5e492af 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -46,6 +46,7 @@ jobs: with: name: Cargo.lock path: Cargo.lock + continue-on-error: true msrv: name: Rust 1.61.0 From 5b36e375c2f6b0a8189134f34b7c8f5ca3ec28d1 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 9 Nov 2024 22:05:33 -0800 Subject: [PATCH 089/131] Add ui test of invalid expression syntax in display attribute --- tests/ui/expression-fallback.rs | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 tests/ui/expression-fallback.rs diff --git a/tests/ui/expression-fallback.rs b/tests/ui/expression-fallback.rs new file mode 100644 index 0000000..7269129 --- /dev/null +++ b/tests/ui/expression-fallback.rs @@ -0,0 +1,7 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("".yellow)] +pub struct ArgError; + +fn main() {} From 591a44d9a37b0326e808df7ef38a6a101badab17 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 9 Nov 2024 22:18:07 -0800 Subject: [PATCH 090/131] Fix fallback fmt expression parser hang --- impl/src/fmt.rs | 2 ++ tests/ui/expression-fallback.stderr | 19 +++++++++++++++++++ 2 files changed, 21 insertions(+) create mode 100644 tests/ui/expression-fallback.stderr diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 3d1394c..d2ab353 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -193,6 +193,8 @@ fn fallback_explicit_named_args(input: ParseStream) -> Result { let ident = input.call(Ident::parse_any)?; input.parse::()?; args.named.insert(ident); + } else { + input.parse::()?; } } diff --git a/tests/ui/expression-fallback.stderr b/tests/ui/expression-fallback.stderr new file mode 100644 index 0000000..5c9f215 --- /dev/null +++ b/tests/ui/expression-fallback.stderr @@ -0,0 +1,19 @@ +error: expected `,`, found `.` + --> tests/ui/expression-fallback.rs:4:11 + | +4 | #[error("".yellow)] + | ^ expected `,` + +error: argument never used + --> tests/ui/expression-fallback.rs:4:12 + | +4 | #[error("".yellow)] + | -- ^^^^^^ argument never used + | | + | formatting specifier missing + +error[E0425]: cannot find value `yellow` in this scope + --> tests/ui/expression-fallback.rs:4:12 + | +4 | #[error("".yellow)] + | ^^^^^^ not found in this scope From 41938bd3a03a70d34ed8e53d99c89c770c7c9c41 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 9 Nov 2024 22:23:49 -0800 Subject: [PATCH 091/131] Release 1.0.69 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 23f3609..9fadb0a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "1.0.68" +version = "1.0.69" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -12,7 +12,7 @@ repository = "https://github.com/dtolnay/thiserror" rust-version = "1.61" [dependencies] -thiserror-impl = { version = "=1.0.68", path = "impl" } +thiserror-impl = { version = "=1.0.69", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 933831e..9936021 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "1.0.68" +version = "1.0.69" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 30715fe..92662f4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -258,7 +258,7 @@ //! //! [`anyhow`]: https://github.com/dtolnay/anyhow -#![doc(html_root_url = "https://docs.rs/thiserror/1.0.68")] +#![doc(html_root_url = "https://docs.rs/thiserror/1.0.69")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 49be39dee10d7fce1d4b2f7f6b6010f2b309794e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 9 Nov 2024 22:28:33 -0800 Subject: [PATCH 092/131] Release 2.0.2 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index ddd289b..2ad54c9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.1" +version = "2.0.2" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.1", path = "impl" } +thiserror-impl = { version = "=2.0.2", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index c0d6ddd..a95699e 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.1" +version = "2.0.2" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 88c2c8f..55c42cd 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.1")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.2")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 520343e37d890e0a4b0c6e1427e8164c43ce1c7d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 12:57:26 -0800 Subject: [PATCH 093/131] Add test of Debug and Display of paths DisplayDebug currently works but DebugDisplay does not. error[E0277]: `PathBuf` doesn't implement `std::fmt::Display` --> tests/test_path.rs:36:13 | 32 | #[derive(Error, Debug)] | ----- in this derive macro expansion ... 36 | #[error("debug:{0:?} display:{0}")] | ^^^^^^^^^^^^^^^^^^^^^^^^^ `PathBuf` cannot be formatted with the default formatter; call `.display()` on it | = help: the trait `std::fmt::Display` is not implemented for `PathBuf` = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead = note: call `.display()` or `.to_string_lossy()` to safely print paths, as they may contain non-Unicode data = help: the trait `std::fmt::Display` is implemented for `Var<'_, T>` = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info) --- tests/test_path.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tests/test_path.rs b/tests/test_path.rs index 16881ae..5bb6972 100644 --- a/tests/test_path.rs +++ b/tests/test_path.rs @@ -29,6 +29,14 @@ pub struct UnsizedError { pub tail: str, } +#[derive(Error, Debug)] +pub enum BothError { + #[error("display:{0} debug:{0:?}")] + DisplayDebug(PathBuf), + #[error("debug:{0:?} display:{0}")] + DebugDisplay(PathBuf), +} + fn assert(expected: &str, value: T) { assert_eq!(expected, value.to_string()); } From dc0359eeecf778da2038805431c61010e7aa957e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 12:51:48 -0800 Subject: [PATCH 094/131] Defer binding_value construction --- impl/src/fmt.rs | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index e99c695..cac0ee3 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -85,15 +85,11 @@ impl Display<'_> { } _ => continue, }; - let binding_value = match &member { - MemberUnraw::Unnamed(index) => format_ident!("_{}", index), - MemberUnraw::Named(ident) => ident.to_local(), - }; - let mut wrapped_binding_value = quote!(::thiserror::__private::Var(#binding_value)); let end_spec = match read.find('}') { Some(end_spec) => end_spec, None => return Ok(()), }; + let mut bonus_display = false; let bound = match read[..end_spec].chars().next_back() { Some('?') => Trait::Debug, Some('o') => Trait::Octal, @@ -105,10 +101,7 @@ impl Display<'_> { Some('E') => Trait::UpperExp, Some(_) => Trait::Display, None => { - has_bonus_display = true; - wrapped_binding_value = quote_spanned! {span=> - #binding_value.as_display() - }; + bonus_display = true; Trait::Display } }; @@ -127,11 +120,21 @@ impl Display<'_> { formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); } out += &formatvar.to_string(); - if macro_named_args.insert(member) { - bindings.push((formatvar.to_local(), wrapped_binding_value)); - } else { + if !macro_named_args.insert(member.clone()) { // Already added to bindings by a previous use. + continue; } + let binding_value = match &member { + MemberUnraw::Unnamed(index) => format_ident!("_{}", index), + MemberUnraw::Named(ident) => ident.to_local(), + }; + let wrapped_binding_value = if bonus_display { + quote_spanned!(span=> #binding_value.as_display()) + } else { + quote!(::thiserror::__private::Var(#binding_value)) + }; + has_bonus_display |= bonus_display; + bindings.push((formatvar.to_local(), wrapped_binding_value)); } out += read; From 63882935be42fbd89e7076392a4d5330e2120332 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 12:55:08 -0800 Subject: [PATCH 095/131] Support Display and Debug of same path in error message --- impl/src/fmt.rs | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index cac0ee3..82fc68e 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -4,7 +4,7 @@ use crate::scan_expr::scan_expr; use crate::unraw::{IdentUnraw, MemberUnraw}; use proc_macro2::{Delimiter, TokenStream, TokenTree}; use quote::{format_ident, quote, quote_spanned}; -use std::collections::{BTreeSet, HashMap, HashSet}; +use std::collections::{BTreeSet, HashMap}; use std::iter; use syn::ext::IdentExt; use syn::parse::discouraged::Speculative; @@ -34,7 +34,7 @@ impl Display<'_> { let mut infinite_recursive = false; let mut implied_bounds = BTreeSet::new(); let mut bindings = Vec::new(); - let mut macro_named_args = HashSet::new(); + let mut macro_named_args = BTreeSet::new(); self.requires_fmt_machinery = self.requires_fmt_machinery || fmt.contains('}'); @@ -112,15 +112,22 @@ impl Display<'_> { out += &member.to_string(); continue; } + let formatvar_prefix = if bonus_display { + "__display" + } else { + "__field" + }; let mut formatvar = IdentUnraw::new(match &member { - MemberUnraw::Unnamed(index) => format_ident!("__field{}", index), - MemberUnraw::Named(ident) => format_ident!("__field_{}", ident.to_string()), + MemberUnraw::Unnamed(index) => format_ident!("{}{}", formatvar_prefix, index), + MemberUnraw::Named(ident) => { + format_ident!("{}_{}", formatvar_prefix, ident.to_string()) + } }); while user_named_args.contains(&formatvar) { formatvar = IdentUnraw::new(format_ident!("_{}", formatvar.to_string())); } out += &formatvar.to_string(); - if !macro_named_args.insert(member.clone()) { + if !macro_named_args.insert(formatvar.clone()) { // Already added to bindings by a previous use. continue; } From 6a6132d79bee8baf89ea0896ec6dadc3ad6b388b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 13:08:49 -0800 Subject: [PATCH 096/131] Extend no-display ui test to cover another fmt trait --- tests/ui/no-display.rs | 6 ++++++ tests/ui/no-display.stderr | 26 ++++++++++++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/tests/ui/no-display.rs b/tests/ui/no-display.rs index 181a66e..d804e00 100644 --- a/tests/ui/no-display.rs +++ b/tests/ui/no-display.rs @@ -9,4 +9,10 @@ pub struct Error { thread: NoDisplay, } +#[derive(Error, Debug)] +#[error("thread: {thread:o}")] +pub struct ErrorOctal { + thread: NoDisplay, +} + fn main() {} diff --git a/tests/ui/no-display.stderr b/tests/ui/no-display.stderr index 88d0092..a60c0d3 100644 --- a/tests/ui/no-display.stderr +++ b/tests/ui/no-display.stderr @@ -18,3 +18,29 @@ note: the trait `std::fmt::Display` must be implemented = help: items from traits can only be used if the trait is implemented and in scope = note: the following trait defines an item `as_display`, perhaps you need to implement it: candidate #1: `AsDisplay` + +error[E0277]: the trait bound `NoDisplay: Octal` is not satisfied + --> tests/ui/no-display.rs:13:9 + | +12 | #[derive(Error, Debug)] + | ----- in this derive macro expansion +13 | #[error("thread: {thread:o}")] + | ^^^^^^^^^^^^^^^^^^^^ the trait `Octal` is not implemented for `NoDisplay` + | + = help: the following other types implement trait `Octal`: + &T + &mut T + NonZero + Saturating + Var<'a, T> + Wrapping + i128 + i16 + and $N others + = note: required for `Var<'_, NoDisplay>` to implement `Octal` +note: required by a bound in `core::fmt::rt::Argument::<'_>::new_octal` + --> $RUST/core/src/fmt/rt.rs + | + | pub fn new_octal(x: &T) -> Argument<'_> { + | ^^^^^ required by this bound in `Argument::<'_>::new_octal` + = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info) From 1d040f358a34d58139f1e1c12cec575319f16edf Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 13:11:08 -0800 Subject: [PATCH 097/131] Use Var wrapper only for Pointer formatting --- impl/src/fmt.rs | 8 ++++-- src/var.rs | 54 +------------------------------------- tests/ui/no-display.stderr | 4 +-- 3 files changed, 9 insertions(+), 57 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 82fc68e..3860b4e 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -3,7 +3,7 @@ use crate::attr::{Display, Trait}; use crate::scan_expr::scan_expr; use crate::unraw::{IdentUnraw, MemberUnraw}; use proc_macro2::{Delimiter, TokenStream, TokenTree}; -use quote::{format_ident, quote, quote_spanned}; +use quote::{format_ident, quote, quote_spanned, ToTokens as _}; use std::collections::{BTreeSet, HashMap}; use std::iter; use syn::ext::IdentExt; @@ -114,6 +114,8 @@ impl Display<'_> { } let formatvar_prefix = if bonus_display { "__display" + } else if bound == Trait::Pointer { + "__pointer" } else { "__field" }; @@ -137,8 +139,10 @@ impl Display<'_> { }; let wrapped_binding_value = if bonus_display { quote_spanned!(span=> #binding_value.as_display()) - } else { + } else if bound == Trait::Pointer { quote!(::thiserror::__private::Var(#binding_value)) + } else { + binding_value.into_token_stream() }; has_bonus_display |= bonus_display; bindings.push((formatvar.to_local(), wrapped_binding_value)); diff --git a/src/var.rs b/src/var.rs index 8643590..ecfcd85 100644 --- a/src/var.rs +++ b/src/var.rs @@ -1,61 +1,9 @@ -use core::fmt::{ - self, Binary, Debug, Display, LowerExp, LowerHex, Octal, Pointer, UpperExp, UpperHex, -}; +use core::fmt::{self, Pointer}; pub struct Var<'a, T: ?Sized>(pub &'a T); -/// Pointer is the only one for which there is a difference in behavior between -/// `Var<'a, T>` vs `&'a T`. impl<'a, T: Pointer + ?Sized> Pointer for Var<'a, T> { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { Pointer::fmt(self.0, formatter) } } - -impl<'a, T: Binary + ?Sized> Binary for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - Binary::fmt(self.0, formatter) - } -} - -impl<'a, T: Debug + ?Sized> Debug for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - Debug::fmt(self.0, formatter) - } -} - -impl<'a, T: Display + ?Sized> Display for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - Display::fmt(self.0, formatter) - } -} - -impl<'a, T: LowerExp + ?Sized> LowerExp for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - LowerExp::fmt(self.0, formatter) - } -} - -impl<'a, T: LowerHex + ?Sized> LowerHex for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - LowerHex::fmt(self.0, formatter) - } -} - -impl<'a, T: Octal + ?Sized> Octal for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - Octal::fmt(self.0, formatter) - } -} - -impl<'a, T: UpperExp + ?Sized> UpperExp for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - UpperExp::fmt(self.0, formatter) - } -} - -impl<'a, T: UpperHex + ?Sized> UpperHex for Var<'a, T> { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - UpperHex::fmt(self.0, formatter) - } -} diff --git a/tests/ui/no-display.stderr b/tests/ui/no-display.stderr index a60c0d3..8f35b82 100644 --- a/tests/ui/no-display.stderr +++ b/tests/ui/no-display.stderr @@ -32,12 +32,12 @@ error[E0277]: the trait bound `NoDisplay: Octal` is not satisfied &mut T NonZero Saturating - Var<'a, T> Wrapping i128 i16 + i32 and $N others - = note: required for `Var<'_, NoDisplay>` to implement `Octal` + = note: required for `&NoDisplay` to implement `Octal` note: required by a bound in `core::fmt::rt::Argument::<'_>::new_octal` --> $RUST/core/src/fmt/rt.rs | From 70460231305d82ae9a7a60424cc4d0d22d0b6e77 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 13:15:40 -0800 Subject: [PATCH 098/131] Simplify how has_bonus_display is accumulated --- impl/src/fmt.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 3860b4e..5c0ff50 100644 --- a/impl/src/fmt.rs +++ b/impl/src/fmt.rs @@ -102,6 +102,7 @@ impl Display<'_> { Some(_) => Trait::Display, None => { bonus_display = true; + has_bonus_display = true; Trait::Display } }; @@ -144,7 +145,6 @@ impl Display<'_> { } else { binding_value.into_token_stream() }; - has_bonus_display |= bonus_display; bindings.push((formatvar.to_local(), wrapped_binding_value)); } From 15fd26e476c5c7a2e7dc13209689c747b1db82a5 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 13:17:27 -0800 Subject: [PATCH 099/131] Release 2.0.3 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 2ad54c9..e1e1a6d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.2" +version = "2.0.3" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.2", path = "impl" } +thiserror-impl = { version = "=2.0.3", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index a95699e..8dbae2f 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.2" +version = "2.0.3" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 55c42cd..5713194 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.2")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.3")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From ad2f20b9f72d2ad998727c7ed1c1d4fc8b7c805a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 10 Nov 2024 23:51:22 -0800 Subject: [PATCH 100/131] Use ui test syntax that does not interfere with rustfmt --- tests/ui/unconditional-recursion.rs | 2 +- tests/ui/unconditional-recursion.stderr | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/ui/unconditional-recursion.rs b/tests/ui/unconditional-recursion.rs index 9e406e8..035b15e 100644 --- a/tests/ui/unconditional-recursion.rs +++ b/tests/ui/unconditional-recursion.rs @@ -5,5 +5,5 @@ use thiserror::Error; pub struct Error; fn main() { - @//fail + __FAIL__; } diff --git a/tests/ui/unconditional-recursion.stderr b/tests/ui/unconditional-recursion.stderr index 72ee5dc..568e891 100644 --- a/tests/ui/unconditional-recursion.stderr +++ b/tests/ui/unconditional-recursion.stderr @@ -1,8 +1,8 @@ -error: expected expression, found `@` +error[E0425]: cannot find value `__FAIL__` in this scope --> tests/ui/unconditional-recursion.rs:8:5 | -8 | @//fail - | ^ expected expression +8 | __FAIL__; + | ^^^^^^^^ not found in this scope warning: function cannot return without recursing --> tests/ui/unconditional-recursion.rs:4:9 From aa19b7cfce13336cb171ad6e8cdb9b50cc1c9dd5 Mon Sep 17 00:00:00 2001 From: Matthew Donoughe Date: Tue, 3 Dec 2024 08:40:10 -0500 Subject: [PATCH 101/131] suppress needless_lifetimes lints from clippy 0.1.83 --- impl/src/expand.rs | 4 ++-- tests/test_lints.rs | 15 +++++++++++++++ 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index e172af9..23e77b6 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -197,7 +197,7 @@ fn impl_struct(input: Struct) -> TokenStream { let source_var = Ident::new("source", span); let body = from_initializer(from_field, backtrace_field, &source_var); quote_spanned! {span=> - #[allow(unused_qualifications)] + #[allow(unused_qualifications, clippy::needless_lifetimes)] #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { #[allow(deprecated)] @@ -462,7 +462,7 @@ fn impl_enum(input: Enum) -> TokenStream { let source_var = Ident::new("source", span); let body = from_initializer(from_field, backtrace_field, &source_var); Some(quote_spanned! {span=> - #[allow(unused_qualifications)] + #[allow(unused_qualifications, clippy::needless_lifetimes)] #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { #[allow(deprecated)] diff --git a/tests/test_lints.rs b/tests/test_lints.rs index cafcbc0..1473682 100644 --- a/tests/test_lints.rs +++ b/tests/test_lints.rs @@ -18,3 +18,18 @@ fn test_unused_qualifications() { let _: MyError; } + +#[test] +fn test_needless_lifetimes() { + #![allow(dead_code)] + #![deny(clippy::needless_lifetimes)] + + #[derive(Debug, Error)] + #[error("...")] + pub enum MyError<'a> { + A(#[from] std::io::Error), + B(&'a ()), + } + + let _: MyError; +} From 70a12613ef6459c90ea69e22cdb41ec20c98e038 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 3 Dec 2024 07:06:42 -0800 Subject: [PATCH 102/131] Release 2.0.4 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index e1e1a6d..6fe18b8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.3" +version = "2.0.4" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.3", path = "impl" } +thiserror-impl = { version = "=2.0.4", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 8dbae2f..8c799d1 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.3" +version = "2.0.4" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 5713194..d90acc1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.3")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.4")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 2096b11bed32583484b0f71b23cdc5b79707173c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 7 Dec 2024 08:46:15 -0800 Subject: [PATCH 103/131] Fold test_deprecated into test_lints --- tests/test_deprecated.rs | 10 ---------- tests/test_lints.rs | 15 +++++++++++++++ 2 files changed, 15 insertions(+), 10 deletions(-) delete mode 100644 tests/test_deprecated.rs diff --git a/tests/test_deprecated.rs b/tests/test_deprecated.rs deleted file mode 100644 index 5524666..0000000 --- a/tests/test_deprecated.rs +++ /dev/null @@ -1,10 +0,0 @@ -#![deny(deprecated, clippy::all, clippy::pedantic)] - -use thiserror::Error; - -#[derive(Error, Debug)] -pub enum Error { - #[deprecated] - #[error("...")] - Deprecated, -} diff --git a/tests/test_lints.rs b/tests/test_lints.rs index 1473682..85a5011 100644 --- a/tests/test_lints.rs +++ b/tests/test_lints.rs @@ -33,3 +33,18 @@ fn test_needless_lifetimes() { let _: MyError; } + +#[test] +fn test_deprecated() { + #![deny(deprecated)] + + #[derive(Error, Debug)] + pub enum MyError { + #[deprecated] + #[error("...")] + Deprecated, + } + + #[allow(deprecated)] + let _ = MyError::Deprecated; +} From 42b146061282670be6a7baf982ba139de8a60940 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 7 Dec 2024 08:48:24 -0800 Subject: [PATCH 104/131] Standardize on 'Error, Debug' derive order --- tests/test_display.rs | 4 ++-- tests/test_lints.rs | 4 ++-- tests/ui/from-not-source.rs | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/test_display.rs b/tests/test_display.rs index 1980d55..5ee6e36 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -271,13 +271,13 @@ fn test_macro_rules() { 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), diff --git a/tests/test_lints.rs b/tests/test_lints.rs index 85a5011..6c39fba 100644 --- a/tests/test_lints.rs +++ b/tests/test_lints.rs @@ -12,7 +12,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; @@ -24,7 +24,7 @@ fn test_needless_lifetimes() { #![allow(dead_code)] #![deny(clippy::needless_lifetimes)] - #[derive(Debug, Error)] + #[derive(Error, Debug)] #[error("...")] pub enum MyError<'a> { A(#[from] std::io::Error), diff --git a/tests/ui/from-not-source.rs b/tests/ui/from-not-source.rs index d1855be..ad72867 100644 --- a/tests/ui/from-not-source.rs +++ b/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, From 0ba7d01e8ea67ae0f84ab50043f75adbe2903b5e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 7 Dec 2024 08:42:53 -0800 Subject: [PATCH 105/131] Add tests of deprecated error types error: use of deprecated struct `test_deprecated::DeprecatedStruct` --> tests/test_lints.rs:44:16 | 44 | pub struct DeprecatedStruct; | ^^^^^^^^^^^^^^^^ | note: the lint level is defined here --> tests/test_lints.rs:39:13 | 39 | #![deny(deprecated)] | ^^^^^^^^^^ error: use of deprecated struct `test_deprecated::DeprecatedStruct` --> tests/test_lints.rs:44:16 | 44 | pub struct DeprecatedStruct; | ^^^^^^^^^^^^^^^^ error: use of deprecated enum `test_deprecated::DeprecatedEnum` --> tests/test_lints.rs:55:14 | 55 | pub enum DeprecatedEnum { | ^^^^^^^^^^^^^^ --- tests/test_lints.rs | 31 ++++++++++++++++++++++++++++--- 1 file changed, 28 insertions(+), 3 deletions(-) diff --git a/tests/test_lints.rs b/tests/test_lints.rs index 6c39fba..b46a391 100644 --- a/tests/test_lints.rs +++ b/tests/test_lints.rs @@ -39,12 +39,37 @@ fn test_deprecated() { #![deny(deprecated)] #[derive(Error, Debug)] - pub enum MyError { + #[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("...")] - Deprecated, + Variant, } #[allow(deprecated)] - let _ = MyError::Deprecated; + let _: DeprecatedStruct; + #[allow(deprecated)] + let _: DeprecatedStructField; + #[allow(deprecated)] + let _ = DeprecatedEnum::Variant; + #[allow(deprecated)] + let _ = DeprecatedVariant::Variant; } From 714229d8214e77df019254afbbca18f1c921737e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 6 Dec 2024 11:00:27 -0800 Subject: [PATCH 106/131] Work around deprecation warning on generated impl for deprecated type --- impl/src/expand.rs | 16 ++++++++++++---- tests/ui/missing-display.stderr | 7 ++++--- 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 23e77b6..d657da7 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -2,7 +2,7 @@ use crate::ast::{Enum, Field, Input, Struct}; use crate::attr::Trait; 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}; @@ -27,7 +27,7 @@ fn try_expand(input: &DeriveInput) -> Result { } fn fallback(input: &DeriveInput, error: syn::Error) -> 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 error = error.to_compile_error(); @@ -55,7 +55,7 @@ fn fallback(input: &DeriveInput, error: syn::Error) -> TokenStream { } 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(); @@ -228,7 +228,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(); @@ -492,6 +492,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. +fn call_site_ident(ident: &Ident) -> Ident { + let mut ident = ident.clone(); + ident.set_span(Span::call_site()); + ident +} + fn fields_pat(fields: &[Field]) -> TokenStream { let mut members = fields.iter().map(|field| &field.member).peekable(); match members.peek() { diff --git a/tests/ui/missing-display.stderr b/tests/ui/missing-display.stderr index 48c9ded..7b55ad3 100644 --- a/tests/ui/missing-display.stderr +++ b/tests/ui/missing-display.stderr @@ -1,8 +1,8 @@ error[E0277]: `MyError` doesn't implement `std::fmt::Display` - --> tests/ui/missing-display.rs:4:10 + --> tests/ui/missing-display.rs:3:10 | -4 | pub enum MyError { - | ^^^^^^^ `MyError` cannot be formatted with the default formatter +3 | #[derive(Error, Debug)] + | ^^^^^ `MyError` cannot be formatted with the default formatter | = help: the trait `std::fmt::Display` is not implemented for `MyError` = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead @@ -11,3 +11,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) From 07e7d990facdfdbd559df323dae1f5deb1ba9ab6 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 7 Dec 2024 08:56:02 -0800 Subject: [PATCH 107/131] Add "in this derive macro expansion" to missing Display errors --- impl/src/expand.rs | 2 +- tests/ui/missing-display.stderr | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index d657da7..52782e3 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -496,7 +496,7 @@ fn impl_enum(input: Enum) -> TokenStream { // deprecated type without triggering deprecation warning on the generated impl. fn call_site_ident(ident: &Ident) -> Ident { let mut ident = ident.clone(); - ident.set_span(Span::call_site()); + ident.set_span(ident.span().resolved_at(Span::call_site())); ident } diff --git a/tests/ui/missing-display.stderr b/tests/ui/missing-display.stderr index 7b55ad3..f7a044b 100644 --- a/tests/ui/missing-display.stderr +++ b/tests/ui/missing-display.stderr @@ -1,8 +1,10 @@ error[E0277]: `MyError` doesn't implement `std::fmt::Display` - --> tests/ui/missing-display.rs:3:10 + --> tests/ui/missing-display.rs:4:10 | 3 | #[derive(Error, Debug)] - | ^^^^^ `MyError` cannot be formatted with the default formatter + | ----- in this derive macro expansion +4 | pub enum MyError { + | ^^^^^^^ `MyError` cannot be formatted with the default formatter | = help: the trait `std::fmt::Display` is not implemented for `MyError` = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead From 88a46035e1bbb17ada53acf28ed7b7b00a0b049a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 7 Dec 2024 09:02:44 -0800 Subject: [PATCH 108/131] Move fallback expansion to separate module --- impl/src/expand.rs | 33 +++------------------------------ impl/src/fallback.rs | 32 ++++++++++++++++++++++++++++++++ impl/src/lib.rs | 1 + 3 files changed, 36 insertions(+), 30 deletions(-) create mode 100644 impl/src/fallback.rs diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 52782e3..d0b302b 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -1,5 +1,6 @@ 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, Span, TokenStream}; @@ -13,7 +14,7 @@ pub fn derive(input: &DeriveInput) -> TokenStream { // 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 // this type as an Error. - Err(error) => fallback(input, error), + Err(error) => fallback::expand(input, error), } } @@ -26,34 +27,6 @@ fn try_expand(input: &DeriveInput) -> Result { }) } -fn fallback(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!() - } - } - } -} - fn impl_struct(input: Struct) -> TokenStream { let ty = call_site_ident(&input.ident); let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl(); @@ -494,7 +467,7 @@ 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. -fn call_site_ident(ident: &Ident) -> Ident { +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 diff --git a/impl/src/fallback.rs b/impl/src/fallback.rs new file mode 100644 index 0000000..e9c429b --- /dev/null +++ b/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!() + } + } + } +} diff --git a/impl/src/lib.rs b/impl/src/lib.rs index 5148323..7f3767e 100644 --- a/impl/src/lib.rs +++ b/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; From f1f159d7e759e986335ed14dd362eb7d6c9815d4 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 7 Dec 2024 09:04:57 -0800 Subject: [PATCH 109/131] Release 2.0.5 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 6fe18b8..f0785d8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.4" +version = "2.0.5" authors = ["David Tolnay "] 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.5", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 8c799d1..efbe2ea 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.4" +version = "2.0.5" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index d90acc1..704b20a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`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.5")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From caf585c978f43ef0348dcd669af301e7a7e8578b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 8 Dec 2024 10:34:17 -0800 Subject: [PATCH 110/131] Add test of deprecated type in From impl error: use of deprecated struct `test_deprecated::DeprecatedStruct` --> tests/test_lints.rs:73:13 | 73 | DeprecatedStruct, | ^^^^^^^^^^^^^^^^ | note: the lint level is defined here --> tests/test_lints.rs:39:13 | 39 | #![deny(deprecated)] | ^^^^^^^^^^ --- tests/test_lints.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tests/test_lints.rs b/tests/test_lints.rs index b46a391..d272454 100644 --- a/tests/test_lints.rs +++ b/tests/test_lints.rs @@ -64,6 +64,16 @@ fn test_deprecated() { Variant, } + #[derive(Error, Debug)] + pub enum DeprecatedFrom { + #[error(transparent)] + Variant( + #[from] + #[allow(deprecated)] + DeprecatedStruct, + ), + } + #[allow(deprecated)] let _: DeprecatedStruct; #[allow(deprecated)] From 6e8c7244c9b396f0c194a660fcb4bcff75e50b08 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 8 Dec 2024 10:37:43 -0800 Subject: [PATCH 111/131] Suppress deprecation warning on generated From impls --- impl/src/expand.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index d0b302b..20ba1d2 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -170,10 +170,9 @@ fn impl_struct(input: Struct) -> TokenStream { let source_var = Ident::new("source", span); let body = from_initializer(from_field, backtrace_field, &source_var); quote_spanned! {span=> - #[allow(unused_qualifications, clippy::needless_lifetimes)] + #[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)] #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { - #[allow(deprecated)] fn from(#source_var: #from) -> Self { #ty #body } @@ -435,10 +434,9 @@ fn impl_enum(input: Enum) -> TokenStream { let source_var = Ident::new("source", span); let body = from_initializer(from_field, backtrace_field, &source_var); Some(quote_spanned! {span=> - #[allow(unused_qualifications, clippy::needless_lifetimes)] + #[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)] #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { - #[allow(deprecated)] fn from(#source_var: #from) -> Self { #ty::#variant #body } From 2075e87257e5bfe458cc01bc3764dcd499db254d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 8 Dec 2024 10:39:40 -0800 Subject: [PATCH 112/131] Release 2.0.6 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f0785d8..1c4f588 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.5" +version = "2.0.6" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.5", path = "impl" } +thiserror-impl = { version = "=2.0.6", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index efbe2ea..134741b 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.5" +version = "2.0.6" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 704b20a..2110b94 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.5")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.6")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 485c2b7eed2702c4a109be3cf42bb4be27fe16bd Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sun, 8 Dec 2024 11:28:58 -0800 Subject: [PATCH 113/131] Reword spurious errors comment --- impl/src/expand.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 20ba1d2..4441a24 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -12,7 +12,7 @@ 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::expand(input, error), } From 100d9164f2b2dbfb5ffcafc19fd925f55626acc0 Mon Sep 17 00:00:00 2001 From: Andres Suarez Date: Fri, 13 Dec 2024 14:06:02 -0800 Subject: [PATCH 114/131] Avoid associating #[from] with lint allow --- impl/src/expand.rs | 16 +++++++++++----- tests/test_lints.rs | 11 +++++++++++ 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index 4441a24..c89985f 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -169,15 +169,18 @@ 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=> - #[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)] + let impl_impl = quote_spanned! {span=> #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { fn from(#source_var: #from) -> Self { #ty #body } } - } + }; + Some(quote! { + #[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)] + #impl_impl + }) }); if input.generics.type_params().next().is_some() { @@ -433,14 +436,17 @@ 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=> - #[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)] + let impl_impl = quote_spanned! {span=> #[automatically_derived] impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause { fn from(#source_var: #from) -> Self { #ty::#variant #body } } + }; + Some(quote! { + #[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)] + #impl_impl }) }); diff --git a/tests/test_lints.rs b/tests/test_lints.rs index d272454..af5830d 100644 --- a/tests/test_lints.rs +++ b/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)] From 9c0f2d230da33dfec248d48d82c25a2ad19e6129 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 13 Dec 2024 14:42:57 -0800 Subject: [PATCH 115/131] Release 2.0.7 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 1c4f588..16df110 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.6" +version = "2.0.7" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.6", path = "impl" } +thiserror-impl = { version = "=2.0.7", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 134741b..bc58661 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.6" +version = "2.0.7" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 2110b94..82b815c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.6")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.7")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 6a07345135802344616a09584c94e2f4bbceb466 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 17 Dec 2024 19:13:28 -0800 Subject: [PATCH 116/131] Add regression test for issue 398 error[E0425]: cannot find value `_0` in this scope --> tests/test_display.rs:308:17 | 308 | #[error("{0}")] | ^^^^^ not found in this scope error[E0425]: cannot find value `__display_x` in this scope --> tests/test_display.rs:310:17 | 310 | #[error("{x}")] | ^^^^^ not found in this scope --- tests/test_display.rs | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/tests/test_display.rs b/tests/test_display.rs index 5ee6e36..71c4a4a 100644 --- a/tests/test_display.rs +++ b/tests/test_display.rs @@ -266,7 +266,7 @@ 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 { @@ -291,6 +291,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)] From f1243a0ceb1c596f808c8df8d1240ed301135a1b Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 17 Dec 2024 18:49:14 -0800 Subject: [PATCH 117/131] Fix spans on macro-generated bindings and format variables --- impl/src/fmt.rs | 18 +++++++++++------- impl/src/unraw.rs | 4 ++++ 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/impl/src/fmt.rs b/impl/src/fmt.rs index 5c0ff50..1da28c1 100644 --- a/impl/src/fmt.rs +++ b/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) { - implied_bounds.insert((field, bound)); - } else { - out += &member.to_string(); - continue; - } + let field = match member_index.get(&member) { + Some(&field) => field, + None => { + out += &member.to_string(); + 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 { diff --git a/impl/src/unraw.rs b/impl/src/unraw.rs index a232621..73b9970 100644 --- a/impl/src/unraw.rs +++ b/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 { From 2bd29821f4ea339c60edfcf4734499d68128eb2e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 17 Dec 2024 19:18:03 -0800 Subject: [PATCH 118/131] Release 2.0.8 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 16df110..578608b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.7" +version = "2.0.8" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.7", path = "impl" } +thiserror-impl = { version = "=2.0.8", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index bc58661..cd6fd90 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.7" +version = "2.0.8" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 82b815c..579865a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.7")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.8")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From c0083752681756b7ad1aae2e6a15717d3d27118d Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 21 Dec 2024 10:20:21 -0800 Subject: [PATCH 119/131] FIx typo in ui test --- tests/ui/same-from-type.rs | 2 +- tests/ui/same-from-type.stderr | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/ui/same-from-type.rs b/tests/ui/same-from-type.rs index bc32b07..0ebdf45 100644 --- a/tests/ui/same-from-type.rs +++ b/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() {} diff --git a/tests/ui/same-from-type.stderr b/tests/ui/same-from-type.stderr index 92944d2..a655163 100644 --- a/tests/ui/same-from-type.stderr +++ b/tests/ui/same-from-type.stderr @@ -4,5 +4,5 @@ error[E0119]: conflicting implementations of trait `From` 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` From e5169bb127f835d5fc390a5ca9acd673d075e21e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 21 Dec 2024 10:22:33 -0800 Subject: [PATCH 120/131] Unspan From impl contents --- impl/src/expand.rs | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/impl/src/expand.rs b/impl/src/expand.rs index fdda851..a304632 100644 --- a/impl/src/expand.rs +++ b/impl/src/expand.rs @@ -169,12 +169,15 @@ 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); + let from_function = quote! { + 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 { - fn from(#source_var: #from) -> Self { - #ty #body - } + #from_function } }; Some(quote! { @@ -436,12 +439,15 @@ 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); + let from_function = quote! { + 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 { - fn from(#source_var: #from) -> Self { - #ty::#variant #body - } + #from_function } }; Some(quote! { From c535cecb6f8d98cbdc72f526fc4c8a8ae826e2a3 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 21 Dec 2024 10:26:04 -0800 Subject: [PATCH 121/131] Release 2.0.9 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 578608b..fed8f7a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.8" +version = "2.0.9" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.8", path = "impl" } +thiserror-impl = { version = "=2.0.9", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index cd6fd90..d08bcf9 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.8" +version = "2.0.9" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 579865a..5145c1c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.8")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.9")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 136859154b88758e33a5cbe57d7bd70f1d31615f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 8 Jan 2025 11:34:40 -0800 Subject: [PATCH 122/131] Add regression test for issue 405 error[E0599]: the method `as_display` exists for reference `&::Err`, but its trait bounds were not satisfied --> tests/test_generics.rs:178:13 | 178 | #[error("couldn't parse entry: {0}")] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ method cannot be called on `&::Err` due to unsatisfied trait bounds | = note: the following trait bounds were not satisfied: `::Err: std::fmt::Display` which is required by `&::Err: AsDisplay<'_>` --- tests/test_generics.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tests/test_generics.rs b/tests/test_generics.rs index 36f1181..bcbfee0 100644 --- a/tests/test_generics.rs +++ b/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 { #[error(transparent)] pub struct StructTransparentGeneric(pub E); +// Should expand to: +// +// impl Display for AssociatedTypeError +// where +// T::Err: Display; +// +// impl Error for AssociatedTypeError +// where +// Self: Debug + Display; +// +#[derive(Error, Debug)] +pub enum AssociatedTypeError { + #[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() { From 6b3e1e50b27d9f90fd4a4be098d4693e50609784 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 8 Jan 2025 11:41:16 -0800 Subject: [PATCH 123/131] Generate trait bounds on associated types --- impl/src/generics.rs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/impl/src/generics.rs b/impl/src/generics.rs index 254c2ed..26fe0a9 100644 --- a/impl/src/generics.rs +++ b/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(ident) = ty.path.get_ident() { - if in_scope.names.contains(ident) { - *found = true; - } + if let Some(qself) = &ty.qself { + crawl(in_scope, &qself.ty, found); + } else { + 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 { From 349f6960ff02d64bec38de392850ea9aa07bb766 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 8 Jan 2025 11:46:25 -0800 Subject: [PATCH 124/131] Release 2.0.10 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index fed8f7a..23fa32a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.9" +version = "2.0.10" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.9", path = "impl" } +thiserror-impl = { version = "=2.0.10", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index d08bcf9..069f2eb 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.9" +version = "2.0.10" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 5145c1c..83835e8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.9")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.10")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 693a6cddad750d0401942d553969310193ec2614 Mon Sep 17 00:00:00 2001 From: Maytham Alsudany Date: Fri, 10 Jan 2025 18:43:36 +0800 Subject: [PATCH 125/131] Add feature gate to tests that use std --- tests/test_expr.rs | 1 + tests/test_path.rs | 2 ++ 2 files changed, 3 insertions(+) diff --git a/tests/test_expr.rs b/tests/test_expr.rs index 4252280..5678e84 100644 --- a/tests/test_expr.rs +++ b/tests/test_expr.rs @@ -90,6 +90,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() { diff --git a/tests/test_path.rs b/tests/test_path.rs index 5bb6972..fa85c1d 100644 --- a/tests/test_path.rs +++ b/tests/test_path.rs @@ -1,3 +1,5 @@ +#![cfg(feature = "std")] + use core::fmt::Display; use ref_cast::RefCast; use std::path::{Path, PathBuf}; From eecd247cdf7dfa1cee9898dd29d56b0021b5f4d0 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 10 Jan 2025 09:55:44 -0800 Subject: [PATCH 126/131] Add CI step to test with "std" disabled --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5e492af..554873e 100644 --- a/.github/workflows/ci.yml +++ b/.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: From 8b5f2d78f0576d8a64a96bd0b73c2b4eef45e6c9 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 10 Jan 2025 09:56:33 -0800 Subject: [PATCH 127/131] Fix unused import in test when built without std warning: unused import: `std::path::PathBuf` --> tests/test_expr.rs:4:5 | 4 | use std::path::PathBuf; | ^^^^^^^^^^^^^^^^^^ | = note: `#[warn(unused_imports)]` on by default --- tests/test_expr.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_expr.rs b/tests/test_expr.rs index 5678e84..1872fb5 100644 --- a/tests/test_expr.rs +++ b/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; From 1a226ae42c20114f71bd3ed339f9e0351351abce Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 10 Jan 2025 10:00:21 -0800 Subject: [PATCH 128/131] Disable two more integration tests in no-std mode --- tests/test_backtrace.rs | 1 + tests/test_option.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/tests/test_backtrace.rs b/tests/test_backtrace.rs index 2a4cffa..cc25676 100644 --- a/tests/test_backtrace.rs +++ b/tests/test_backtrace.rs @@ -1,3 +1,4 @@ +#![cfg(feature = "std")] #![cfg_attr(thiserror_nightly_testing, feature(error_generic_member_access))] use thiserror::Error; diff --git a/tests/test_option.rs b/tests/test_option.rs index fbdbec0..21cd5e1 100644 --- a/tests/test_option.rs +++ b/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)] From 0f532e326e9a4cc6c6e30ee19ab00cb9eeb44362 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Fri, 10 Jan 2025 10:03:49 -0800 Subject: [PATCH 129/131] Release 2.0.11 --- Cargo.toml | 4 ++-- impl/Cargo.toml | 2 +- src/lib.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 23fa32a..2c1b403 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror" -version = "2.0.10" +version = "2.0.11" authors = ["David Tolnay "] categories = ["rust-patterns"] description = "derive(Error)" @@ -28,7 +28,7 @@ default = ["std"] std = [] [dependencies] -thiserror-impl = { version = "=2.0.10", path = "impl" } +thiserror-impl = { version = "=2.0.11", path = "impl" } [dev-dependencies] anyhow = "1.0.73" diff --git a/impl/Cargo.toml b/impl/Cargo.toml index 069f2eb..8ca758f 100644 --- a/impl/Cargo.toml +++ b/impl/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "thiserror-impl" -version = "2.0.10" +version = "2.0.11" authors = ["David Tolnay "] description = "Implementation detail of the `thiserror` crate" edition = "2021" diff --git a/src/lib.rs b/src/lib.rs index 83835e8..99df8bf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -259,7 +259,7 @@ //! [`anyhow`]: https://github.com/dtolnay/anyhow #![no_std] -#![doc(html_root_url = "https://docs.rs/thiserror/2.0.10")] +#![doc(html_root_url = "https://docs.rs/thiserror/2.0.11")] #![allow( clippy::module_name_repetitions, clippy::needless_lifetimes, From 70bc20d8483aed1567324c8ece7c9d0d42a8ddf2 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 22 Jan 2025 19:30:31 -0800 Subject: [PATCH 130/131] Remove **/*.rs.bk from project-specific gitignore Cargo stopped generating this in its project template 5 years ago. It would belong in a global gitignore instead. --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 6936990..96ef6c0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,2 @@ /target -**/*.rs.bk Cargo.lock From 2706873a04a9eec85bf8aa8f83ab4367bd5ff388 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 23 Jan 2025 01:36:08 -0800 Subject: [PATCH 131/131] More precise gitignore patterns --- .gitignore | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitignore b/.gitignore index 96ef6c0..e9e2199 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,2 @@ -/target -Cargo.lock +/target/ +/Cargo.lock