mirrors/thiserror
1
0
Fork 0
mirror of https://github.com/dtolnay/thiserror.git synced 2025-04-03 21:07:38 +03:00
Code Issues Projects Releases Packages Wiki Activity

merge

Browse source
This commit is contained in:
Angad Tendulkar 2025-02-06 20:45:12 -05:00
commit 1d1aea6da4
No known key found for this signature in database
59 changed files with 1851 additions and 399 deletions
Download patch file Download diff file Expand all files Collapse all files

21
.github/workflows/ci.yml vendored
View file

@ -24,7 +24,7 @@ jobs:
strategy:
fail-fast: false
matrix:
rust: [nightly, beta, stable, 1.56.0]
rust: [nightly, beta, stable, 1.81.0, 1.70.0]
timeout-minutes: 45
steps:
- uses: actions/checkout@v4
@ -38,12 +38,29 @@ 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'
- run: cargo test --no-default-features
- uses: actions/upload-artifact@v4
if: matrix.rust == 'nightly' && always()
with:
name: Cargo.lock
path: Cargo.lock
continue-on-error: true
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

5
.gitignore vendored
View file

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

24
Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "thiserror"
version = "1.0.63"
version = "2.0.11"
authors = ["David Tolnay <dtolnay@gmail.com>"]
categories = ["rust-patterns"]
description = "derive(Error)"
@ -9,10 +9,26 @@ 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"
[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.63", path = "impl" }
thiserror-impl = { version = "=2.0.11", path = "impl" }
[dev-dependencies]
anyhow = "1.0.73"
@ -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"]

6
README.md
View file

@ -13,10 +13,10 @@ This library provides a convenient derive macro for the standard library's
```toml
[dependencies]
thiserror = "1.0"
thiserror = "2"
```
*Compiler support: requires rustc 1.56+*
*Compiler support: requires rustc 1.61+*
<br>
@ -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),
}
```

62
build.rs
View file

@ -1,14 +1,18 @@
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};
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;
@ -52,6 +56,24 @@ fn main() {
if consider_rustc_bootstrap {
println!("cargo:rerun-if-env-changed=RUSTC_BOOTSTRAP");
}
// 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,
};
// 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 {
@ -68,8 +90,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 +121,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,18 +137,38 @@ 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 rustc_minor_version() -> Option<u32> {
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 ${} is not set during execution of build script",
key,
);
eprintln!("Environment variable ${key} is not set during execution of build script");
process::exit(1);
})
}

3
build/probe.rs
View file

@ -2,10 +2,11 @@
// 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};
use core::fmt::{self, Debug, Display};
use std::error::{Error, Request};
struct MyError(Thing);
struct Thing;

6
impl/Cargo.toml
View file

@ -1,12 +1,12 @@
[package]
name = "thiserror-impl"
version = "1.0.63"
version = "2.0.11"
authors = ["David Tolnay <dtolnay@gmail.com>"]
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
@ -14,7 +14,7 @@ proc-macro = true
[dependencies]
proc-macro2 = "1.0.74"
quote = "1.0.35"
syn = "2.0.46"
syn = "2.0.87"
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]

106
impl/src/ast.rs
View file

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

119
impl/src/attr.rs
View file

@ -1,20 +1,21 @@
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::ParseStream;
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> {
pub display: Option<Display<'a>>,
pub source: Option<&'a Attribute>,
pub source: Option<Source<'a>>,
pub backtrace: Option<&'a Attribute>,
pub location: Option<&'a Attribute>,
pub from: Option<&'a Attribute>,
pub from: Option<From<'a>>,
pub transparent: Option<Transparent<'a>>,
pub fmt: Option<Fmt<'a>>,
}
#[derive(Clone)]
@ -24,7 +25,21 @@ 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)>,
}
#[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)]
@ -33,6 +48,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,
@ -54,6 +75,7 @@ pub fn get(input: &[Attribute]) -> Result<Attrs> {
location: None,
from: None,
transparent: None,
fmt: None,
};
for attr in input {
@ -64,7 +86,13 @@ pub fn get(input: &[Attribute]) -> Result<Attrs> {
if attrs.source.is_some() {
return Err(Error::new_spanned(attr, "duplicate #[source] attribute"));
}
attrs.source = Some(attr);
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,
});
} else if attr.path().is_ident("backtrace") {
attr.meta.require_path_only()?;
if attrs.backtrace.is_some() {
@ -88,7 +116,13 @@ pub fn get(input: &[Attribute]) -> Result<Attrs> {
if attrs.from.is_some() {
return Err(Error::new_spanned(attr, "duplicate #[from] attribute"));
}
attrs.from = Some(attr);
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,
});
}
}
@ -96,10 +130,17 @@ pub fn get(input: &[Attribute]) -> Result<Attrs> {
}
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| {
if let Some(kw) = input.parse::<Option<transparent>>()? {
let lookahead = input.lookahead1();
let fmt = if lookahead.peek(LitStr) {
input.parse::<LitStr>()?
} else if lookahead.peek(kw::transparent) {
let kw: kw::transparent = input.parse()?;
if attrs.transparent.is_some() {
return Err(Error::new_spanned(
attr,
@ -111,14 +152,27 @@ 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::<kw::fmt>()?;
input.parse::<Token![=]>()?;
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());
};
let fmt: LitStr = input.parse()?;
let ahead = input.fork();
ahead.parse::<Option<Token![,]>>()?;
let args = if ahead.is_empty() {
input.advance_to(&ahead);
let args = if input.is_empty() || input.peek(Token![,]) && input.peek2(End) {
input.parse::<Option<Token![,]>>()?;
TokenStream::new()
} else {
parse_token_expr(input, false)?
@ -132,7 +186,9 @@ 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(),
};
if attrs.display.is_some() {
return Err(Error::new_spanned(
@ -148,6 +204,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<TokenStream> {
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::<Token![.]>()?;
@ -246,13 +309,21 @@ fn parse_token_expr(input: ParseStream, mut begin_expr: bool) -> Result<TokenStr
impl ToTokens for Display<'_> {
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;
// 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)
}
@ -260,6 +331,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
}
}
});
}
}

223
impl/src/expand.rs
View file

@ -1,19 +1,20 @@
use crate::ast::{Enum, Field, Input, Struct};
use crate::attr::Trait;
use crate::fallback;
use crate::generics::InferredBounds;
use crate::span::MemberSpan;
use proc_macro2::TokenStream;
use crate::unraw::MemberUnraw;
use proc_macro2::{Ident, Span, 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) {
Ok(expanded) => expanded,
// If there are invalid attributes in the input, expand to an Error impl
// anyway to minimize spurious knock-on errors in other code that uses
// anyway to minimize spurious secondary errors in other code that uses
// this type as an Error.
Err(error) => fallback(input, error),
Err(error) => fallback::expand(input, error),
}
}
@ -26,54 +27,28 @@ fn try_expand(input: &DeriveInput) -> Result<TokenStream> {
})
}
fn fallback(input: &DeriveInput, error: syn::Error) -> TokenStream {
let ty = &input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let error = error.to_compile_error();
quote! {
#error
#[allow(unused_qualifications)]
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
for<'workaround> #ty #ty_generics: ::core::fmt::Debug,
{}
#[allow(unused_qualifications)]
impl #impl_generics ::core::fmt::Display for #ty #ty_generics #where_clause {
fn fmt(&self, __formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::unreachable!()
}
}
}
}
fn impl_struct(input: Struct) -> TokenStream {
let ty = &input.ident;
let ty = call_site_ident(&input.ident);
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let mut error_inferred_bounds = InferredBounds::new();
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.member_span()=> .as_ref()?))
Some(quote_spanned!(source.span()=> .as_ref()?))
} else {
None
};
@ -88,8 +63,8 @@ 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 _;
fn source(&self) -> ::core::option::Option<&(dyn ::thiserror::__private::Error + 'static)> {
use ::thiserror::__private::AsDynError as _;
#body
}
}
@ -101,13 +76,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);
}
};
@ -116,12 +91,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);
})
};
let location_provide = if let Some(location_field) = input.location_field() {
@ -142,7 +117,7 @@ fn impl_struct(input: Struct) -> TokenStream {
None
};
quote! {
use thiserror::__private::ThiserrorProvide as _;
use ::thiserror::__private::ThiserrorProvide as _;
#source_provide
#self_provide
#location_provide
@ -150,16 +125,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::<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! {
fn provide<'_request>(&'_request self, #request: &mut std::error::Request<'_request>) {
fn provide<'_request>(&'_request self, #request: &mut ::core::error::Request<'_request>) {
#body
}
}
@ -196,6 +171,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 {
@ -206,21 +182,33 @@ 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, input.location_field());
let track_caller = input.location_field().map(|_| quote!(#[track_caller]));
quote! {
#[allow(unused_qualifications)]
impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause {
#[allow(deprecated)]
#track_caller
fn from(source: #from) -> Self {
#ty #body
}
let source_var = Ident::new("source", span);
let body = from_initializer(
from_field,
backtrace_field,
&source_var,
input.location_field(),
);
let from_function = quote! {
#track_caller
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 {
#from_function
}
};
Some(quote! {
#[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)]
#from_impl
})
});
if input.generics.type_params().next().is_some() {
@ -232,7 +220,8 @@ fn impl_struct(input: Struct) -> TokenStream {
quote! {
#[allow(unused_qualifications)]
impl #impl_generics std::error::Error for #ty #ty_generics #error_where_clause {
#[automatically_derived]
impl #impl_generics ::thiserror::__private::Error for #ty #ty_generics #error_where_clause {
#source_method
#provide_method
}
@ -242,7 +231,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();
@ -252,11 +241,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,
@ -265,10 +254,10 @@ 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.member_span()=> .as_ref()?))
Some(quote_spanned!(source.span()=> .as_ref()?))
} else {
None
};
@ -286,8 +275,8 @@ fn impl_enum(input: Enum) -> TokenStream {
}
});
Some(quote! {
fn source(&self) -> ::core::option::Option<&(dyn std::error::Error + 'static)> {
use thiserror::__private::AsDynError as _;
fn source(&self) -> ::core::option::Option<&(dyn ::thiserror::__private::Error + 'static)> {
use ::thiserror::__private::AsDynError as _;
#[allow(deprecated)]
match self {
#(#arms)*
@ -322,13 +311,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);
}
};
@ -341,12 +330,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);
}
};
@ -359,13 +348,13 @@ fn impl_enum(input: Enum) -> TokenStream {
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);
}
};
@ -405,8 +394,8 @@ fn impl_enum(input: Enum) -> TokenStream {
}
});
Some(quote! {
fn provide<'_request>(&'_request self, #request: &mut std::error::Request<'_request>) {
#[allow(deprecated, unused_imports)]
fn provide<'_request>(&'_request self, #request: &mut ::core::error::Request<'_request>) {
#[allow(deprecated)]
match self {
#(#arms)*
}
@ -432,19 +421,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 {
Member::Named(ident) => ident.clone(),
Member::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];
@ -462,6 +455,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
@ -478,22 +472,29 @@ 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 location_field = variant.location_field();
let variant = &variant.ident;
let from = unoptional_type(from_field.ty);
let body = from_initializer(from_field, backtrace_field, location_field);
let source_var = Ident::new("source", span);
let body = from_initializer(from_field, backtrace_field, &source_var, location_field);
let track_caller = location_field.map(|_| quote!(#[track_caller]));
Some(quote! {
#[allow(unused_qualifications)]
impl #impl_generics ::core::convert::From<#from> for #ty #ty_generics #where_clause {
#[allow(deprecated)]
#track_caller
fn from(source: #from) -> Self {
#ty::#variant #body
}
let from_function = quote! {
#track_caller
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 {
#from_function
}
};
Some(quote! {
#[allow(deprecated, unused_qualifications, clippy::needless_lifetimes)]
#from_impl
})
});
@ -506,7 +507,8 @@ fn impl_enum(input: Enum) -> TokenStream {
quote! {
#[allow(unused_qualifications)]
impl #impl_generics std::error::Error for #ty #ty_generics #error_where_clause {
#[automatically_derived]
impl #impl_generics ::thiserror::__private::Error for #ty #ty_generics #error_where_clause {
#source_method
#provide_method
}
@ -515,14 +517,22 @@ fn impl_enum(input: Enum) -> TokenStream {
}
}
// Create an ident with which we can expand `impl Trait for #ident {}` on a
// deprecated type without triggering deprecation warning on the generated impl.
pub(crate) fn call_site_ident(ident: &Ident) -> Ident {
let mut ident = ident.clone();
ident.set_span(ident.span().resolved_at(Span::call_site()));
ident
}
fn fields_pat(fields: &[Field]) -> TokenStream {
let mut members = fields.iter().map(|field| &field.member).peekable();
match members.peek() {
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(index) => format_ident!("_{}", index),
MemberUnraw::Named(_) => unreachable!(),
});
quote!((#(#vars),*))
}
@ -533,7 +543,7 @@ fn fields_pat(fields: &[Field]) -> TokenStream {
fn use_as_display(needs_as_display: bool) -> Option<TokenStream> {
if needs_as_display {
Some(quote! {
use thiserror::__private::AsDisplay as _;
use ::thiserror::__private::AsDisplay as _;
})
} else {
None
@ -543,23 +553,24 @@ fn use_as_display(needs_as_display: bool) -> Option<TokenStream> {
fn from_initializer(
from_field: &Field,
backtrace_field: Option<&Field>,
source_var: &Ident,
location_field: Option<&Field>,
) -> 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;
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()),
}
}
});

32
impl/src/fallback.rs Normal file
View file

@ -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!()
}
}
}
}

351
impl/src/fmt.rs
View file

@ -1,36 +1,40 @@
use crate::ast::Field;
use crate::ast::{ContainerKind, Field};
use crate::attr::{Display, Trait};
use proc_macro2::TokenTree;
use quote::{format_ident, quote_spanned};
use std::collections::{BTreeSet as Set, HashMap as Map};
use crate::scan_expr::scan_expr;
use crate::unraw::{IdentUnraw, MemberUnraw};
use proc_macro2::{Delimiter, TokenStream, TokenTree};
use quote::{format_ident, quote, quote_spanned, ToTokens as _};
use std::collections::{BTreeSet, HashMap};
use std::iter;
use syn::ext::IdentExt;
use syn::parse::{ParseStream, Parser};
use syn::{Ident, Index, LitStr, Member, Result, Token};
use syn::parse::discouraged::Speculative;
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], container: ContainerKind) -> Result<()> {
let raw_args = self.args.clone();
let mut named_args = explicit_named_args.parse2(raw_args).unwrap();
let mut member_index = Map::new();
let FmtArguments {
named: user_named_args,
first_unnamed,
} = explicit_named_args.parse2(raw_args).unwrap();
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);
extra_positional_arguments_allowed &= matches!(&field.member, MemberUnraw::Named(_));
}
let span = self.fmt.span();
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 = Set::new();
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;
}
}
let mut infinite_recursive = false;
let mut implied_bounds = BTreeSet::new();
let mut bindings = Vec::new();
let mut macro_named_args = BTreeSet::new();
self.requires_fmt_machinery = self.requires_fmt_machinery || fmt.contains('}');
@ -45,129 +49,274 @@ 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);
let member = match int.parse::<u32>() {
Ok(index) => Member::Unnamed(Index { index, span }),
Err(_) => return,
};
if !member_index.contains_key(&member) {
out += &int;
continue;
if !extra_positional_arguments_allowed {
if let Some(first_unnamed) = &first_unnamed {
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));
}
}
match int.parse::<u32>() {
Ok(index) => MemberUnraw::Unnamed(Index { index, span }),
Err(_) => return Ok(()),
}
member
}
'a'..='z' | 'A'..='Z' | '_' => {
let mut ident = take_ident(&mut read);
ident.set_span(span);
Member::Named(ident)
if read.starts_with("r#") {
continue;
}
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,
};
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 local = match &member {
Member::Unnamed(index) => format_ident!("_{}", index),
Member::Named(ident) => ident.clone(),
let end_spec = match read.find('}') {
Some(end_spec) => end_spec,
None => return Ok(()),
};
let mut formatvar = local.clone();
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);
let mut bonus_display = false;
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 => {
bonus_display = true;
has_bonus_display = true;
Trait::Display
}
};
infinite_recursive |= member == *"self" && bound == Trait::Display;
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 {
"__pointer"
} else {
"__field"
};
let mut formatvar = IdentUnraw::new(match &member {
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()));
}
formatvar.set_span(span);
out += &formatvar.to_string();
if !named_args.insert(formatvar.clone()) {
// Already specified in the format argument list.
if !macro_named_args.insert(formatvar.clone()) {
// Already added to bindings by a previous use.
continue;
}
if !has_trailing_comma {
args.extend(quote_spanned!(span=> ,));
}
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()));
}
has_trailing_comma = false;
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 {
quote!(::thiserror::__private::Var(#binding_value))
} else {
binding_value.into_token_stream()
};
bindings.push((formatvar.to_local(), wrapped_binding_value));
}
out += read;
self.fmt = LitStr::new(&out, self.fmt.span());
self.args = args;
self.has_bonus_display = has_bonus_display;
self.infinite_recursive = infinite_recursive;
self.implied_bounds = implied_bounds;
self.bindings = bindings;
Ok(())
}
}
fn explicit_named_args(input: ParseStream) -> Result<Set<Ident>> {
let mut named_args = Set::new();
struct FmtArguments {
named: BTreeSet<IdentUnraw>,
first_unnamed: Option<TokenStream>,
}
#[allow(clippy::unnecessary_wraps)]
fn explicit_named_args(input: ParseStream) -> Result<FmtArguments> {
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::<TokenStream>().unwrap();
Ok(FmtArguments {
named: BTreeSet::new(),
first_unnamed: None,
})
}
fn try_explicit_named_args(input: ParseStream) -> Result<FmtArguments> {
let mut syn_full = None;
let mut args = FmtArguments {
named: BTreeSet::new(),
first_unnamed: None,
};
while !input.is_empty() {
if input.peek(Token![,]) && input.peek2(Ident::peek_any) && input.peek3(Token![=]) {
input.parse::<Token![,]>()?;
let ident = input.call(Ident::parse_any)?;
input.parse::<Token![,]>()?;
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::<Token![=]>()?;
named_args.insert(ident);
args.named.insert(ident);
} else {
begin_unnamed = Some(input.fork());
}
let ahead = input.fork();
if *syn_full.get_or_insert_with(is_syn_full) && ahead.parse::<Expr>().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));
}
}
}
Ok(args)
}
fn fallback_explicit_named_args(input: ParseStream) -> Result<FmtArguments> {
let mut args = FmtArguments {
named: BTreeSet::new(),
first_unnamed: None,
};
while !input.is_empty() {
if input.peek(Token![,])
&& input.peek2(Ident::peek_any)
&& input.peek3(Token![=])
&& !input.peek3(Token![==])
{
input.parse::<Token![,]>()?;
let ident: IdentUnraw = input.parse()?;
input.parse::<Token![=]>()?;
args.named.insert(ident);
} else {
input.parse::<TokenTree>()?;
}
}
Ok(named_args)
Ok(args)
}
fn take_int(read: &mut &str) -> String {
let mut int = String::new();
for (i, ch) in read.char_indices() {
fn is_syn_full() -> bool {
// Expr::Block contains syn::Block which contains Vec<syn::Stmt>. 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<'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) -> 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() {
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,
}
}
Ident::parse_any.parse_str(&ident).unwrap()
let (ident, rest) = read.split_at(ident_len);
*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
}

12
impl/src/generics.rs
View file

@ -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 {
@ -57,7 +58,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();

5
impl/src/lib.rs
View file

@ -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,
@ -20,10 +21,12 @@ extern crate proc_macro;
mod ast;
mod attr;
mod expand;
mod fallback;
mod fmt;
mod generics;
mod prop;
mod span;
mod scan_expr;
mod unraw;
mod valid;
use proc_macro::TokenStream;

17
impl/src/prop.rs
View file

@ -1,9 +1,9 @@
use crate::ast::{Enum, Field, Struct, Variant};
use crate::span::MemberSpan;
use crate::unraw::MemberUnraw;
use proc_macro2::Span;
use syn::Type;
use syn::{
AngleBracketedGenericArguments, GenericArgument, Lifetime, Member, PathArguments, Type,
TypeReference,
AngleBracketedGenericArguments, GenericArgument, Lifetime, PathArguments, TypeReference,
};
impl Struct<'_> {
@ -45,10 +45,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()
@ -90,11 +91,11 @@ 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.member_span()
self.member.span()
}
}
}
@ -116,7 +117,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),
_ => {}
}
}

264
impl/src/scan_expr.rs Normal file
View file

@ -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::<Option<TokenTree>>()?.is_some(),
Input::ConsumeBinOp => input.parse::<BinOp>().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::<Option<Ident>>()?.is_some(),
Input::ConsumeLifetime => input.parse::<Option<Lifetime>>()?.is_some(),
Input::ConsumeLiteral => input.parse::<Option<Lit>>()?.is_some(),
Input::ExpectPath => {
input.parse::<ExprPath>()?;
true
}
Input::ExpectTurbofish => {
if input.peek(Token![::]) {
input.parse::<AngleBracketedGenericArguments>()?;
}
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"));
}
}

15
impl/src/span.rs
View file

@ -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,
}
}
}

142
impl/src/unraw.rs Normal file
View file

@ -0,0 +1,142 @@
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 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::<Ident>(&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
}
pub fn set_span(&mut self, span: Span) {
self.0.set_span(span);
}
}
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 PartialEq<str> 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())
}
}
impl PartialOrd for IdentUnraw {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(Self::cmp(self, other))
}
}
impl Parse for IdentUnraw {
fn parse(input: ParseStream) -> Result<Self> {
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);
}
}
#[derive(Clone)]
pub enum MemberUnraw {
Named(IdentUnraw),
Unnamed(Index),
}
impl MemberUnraw {
pub fn span(&self) -> Span {
match self {
MemberUnraw::Named(ident) => ident.0.span(),
MemberUnraw::Unnamed(index) => index.span,
}
}
}
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 {
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 PartialEq<str> for MemberUnraw {
fn eq(&self, other: &str) -> bool {
match self {
MemberUnraw::Named(this) => this == other,
MemberUnraw::Unnamed(_) => false,
}
}
}
impl Hash for MemberUnraw {
fn hash<H: Hasher>(&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),
}
}
}

93
impl/src/valid.rs
View file

@ -1,8 +1,6 @@
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, Member, PathArguments, Result, Type};
use syn::{Error, GenericArgument, PathArguments, Result, Type};
impl Input<'_> {
pub(crate) fn validate(&self) -> Result<()> {
@ -25,11 +23,17 @@ 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]",
));
}
}
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()?;
@ -44,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,
@ -52,18 +59,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(())
}
}
@ -80,7 +75,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]",
));
}
@ -95,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",
));
}
@ -108,13 +109,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",
));
}
@ -124,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(())
}
@ -145,13 +158,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);
}
@ -186,9 +205,9 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> {
has_location |= field.is_location();
}
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_field.attrs.from.unwrap().original,
"#[from] is only supported on the source field, not any other field",
));
}
@ -196,14 +215,18 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> {
if let Some(from_field) = from_field {
let extra_fields = has_backtrace as usize + has_location as usize;
let max_expected_fields = match (backtrace_field, location_field) {
(Some(backtrace), Some(_)) => 2 + !same_member(from_field, backtrace) as usize,
(Some(backtrace_field), None) => 1 + !same_member(from_field, backtrace_field) as usize,
(Some(backtrace_field), Some(_)) => {
2 + (from_field.member != backtrace_field.member) as usize
}
(Some(backtrace_field), None) => {
1 + (from_field.member != backtrace_field.member) as usize
}
(None, Some(_)) => 1 + extra_fields,
(None, None) => 1 + extra_fields,
};
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, backtrace, and location",
));
}
@ -219,14 +242,6 @@ fn check_field_attrs(fields: &[Field]) -> Result<()> {
Ok(())
}
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,
_ => unreachable!(),
}
}
fn contains_non_static_lifetime(ty: &Type) -> bool {
match ty {
Type::Path(ty) => {

4
src/aserror.rs
View file

@ -1,5 +1,5 @@
use core::error::Error;
use core::panic::UnwindSafe;
use std::error::Error;
#[doc(hidden)]
pub trait AsDynError<'a>: Sealed {
@ -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<T: Error> 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 {}

45
src/display.rs
View file

@ -1,8 +1,9 @@
use core::fmt::Display;
#[cfg(feature = "std")]
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;
@ -12,7 +13,7 @@ pub trait AsDisplay<'a> {
impl<'a, T> AsDisplay<'a> for &T
where
T: Display + 'a,
T: Display + ?Sized + 'a,
{
type Target = &'a T;
@ -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>;
@ -38,3 +41,41 @@ impl<'a> AsDisplay<'a> for PathBuf {
self.display()
}
}
#[doc(hidden)]
pub trait Sealed {}
impl<T: Display + ?Sized> 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 {}
}

18
src/lib.rs
View file

@ -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),
//! }
//! ```
@ -258,7 +258,8 @@
//!
//! [`anyhow`]: https://github.com/dtolnay/anyhow
#![doc(html_root_url = "https://docs.rs/thiserror/1.0.63")]
#![no_std]
#![doc(html_root_url = "https://docs.rs/thiserror/2.0.11")]
#![allow(
clippy::module_name_repetitions,
clippy::needless_lifetimes,
@ -270,10 +271,16 @@
#[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)]
mod provide;
mod var;
pub use thiserror_impl::*;
@ -287,4 +294,11 @@ pub mod __private {
#[cfg(error_generic_member_access)]
#[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)]
pub use std::backtrace::Backtrace;
}

2
src/provide.rs
View file

@ -1,4 +1,4 @@
use std::error::{Error, Request};
use core::error::{Error, Request};
#[doc(hidden)]
pub trait ThiserrorProvide: Sealed {

9
src/var.rs Normal file
View file

@ -0,0 +1,9 @@
use core::fmt::{self, Pointer};
pub struct Var<'a, T: ?Sized>(pub &'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)
}
}

12
tests/no-std/Cargo.toml Normal file
View file

@ -0,0 +1,12 @@
[package]
name = "thiserror_no_std_test"
version = "0.0.0"
authors = ["David Tolnay <dtolnay@gmail.com>"]
edition = "2021"
publish = false
[lib]
path = "test.rs"
[dependencies]
thiserror = { path = "../..", default-features = false }

58
tests/no-std/test.rs Normal file
View file

@ -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::<SourceError>()
.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~~~");
}
}

12
tests/test_backtrace.rs
View file

@ -1,3 +1,4 @@
#![cfg(feature = "std")]
#![cfg_attr(thiserror_nightly_testing, feature(error_generic_member_access))]
use thiserror::Error;
@ -21,6 +22,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 +40,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 {

10
tests/test_deprecated.rs
View file

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

143
tests/test_display.rs
View file

@ -1,4 +1,9 @@
#![allow(clippy::needless_raw_string_hashes, clippy::uninlined_format_args)]
#![allow(
clippy::needless_lifetimes,
clippy::needless_raw_string_hashes,
clippy::trivially_copy_pass_by_ref,
clippy::uninlined_format_args
)]
use core::fmt::{self, Display};
use thiserror::Error;
@ -127,7 +132,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(),
})]
@ -247,18 +252,32 @@ fn test_nested_tuple_field() {
}
#[test]
fn test_macro_rules() {
fn test_pointer() {
#[derive(Error, Debug)]
#[error("{field:p}")]
pub struct Struct {
field: Box<i32>,
}
let s = Struct {
field: Box::new(-1),
};
assert_eq!(s.to_string(), format!("{:p}", s.field));
}
#[test]
fn test_macro_rules_variant_from_call_site() {
// Regression test for https://github.com/dtolnay/thiserror/issues/86
macro_rules! decl_error {
($variant:ident($value:ident)) => {
#[derive(Debug, Error)]
#[derive(Error, Debug)]
pub enum Error0 {
#[error("{0:?}")]
$variant($value),
}
#[derive(Debug, Error)]
#[derive(Error, Debug)]
#[error("{0:?}")]
pub enum Error1 {
$variant($value),
@ -272,10 +291,34 @@ 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)]
#[error("braced raw error: {r#fn}")]
#[error("braced raw error: {fn}")]
struct Error {
r#fn: &'static str,
}
@ -287,24 +330,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)]
@ -314,6 +346,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)]
@ -368,3 +409,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<T: 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>)]
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));
}

30
tests/test_expr.rs
View file

@ -1,6 +1,8 @@
#![allow(clippy::iter_cloned_collect, clippy::uninlined_format_args)]
use core::fmt::Display;
#[cfg(feature = "std")]
use std::path::PathBuf;
use thiserror::Error;
// Some of the elaborate cases from the rcc codebase, which is a C compiler in
@ -50,6 +52,7 @@ pub enum RustupError {
},
}
#[track_caller]
fn assert<T: Display>(expected: &str, value: T) {
assert_eq!(expected, value.to_string());
}
@ -86,3 +89,30 @@ 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() {
pub trait Trait<T>: Display {
type A;
}
impl<T> Trait<T> for i32 {
type A = i32;
}
#[derive(Error, Debug)]
#[error("{A} {b}", b = &0 as &dyn Trait<i32, A = i32>)]
pub struct Error {
pub A: PathBuf,
}
assert(
"... 0",
Error {
A: PathBuf::from("..."),
},
);
}

44
tests/test_generics.rs
View file

@ -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;
@ -159,3 +160,46 @@ pub struct StructFromGeneric<E> {
#[derive(Error, Debug)]
#[error(transparent)]
pub struct StructTransparentGeneric<E>(pub E);
// Should expand to:
//
// impl<T: FromStr> Display for AssociatedTypeError<T>
// where
// T::Err: Display;
//
// impl<T: FromStr> Error for AssociatedTypeError<T>
// where
// Self: Debug + Display;
//
#[derive(Error, Debug)]
pub enum AssociatedTypeError<T: FromStr> {
#[error("couldn't parse matrix")]
Other,
#[error("couldn't parse entry: {0}")]
EntryParseError(T::Err),
}
// Regression test for https://github.com/dtolnay/thiserror/issues/345
#[test]
fn test_no_bound_on_named_fmt() {
#[derive(Error, Debug)]
#[error("{thing}", thing = "...")]
struct Error<T> {
thing: T,
}
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<T> {
thing: T,
}
let error = Error { thing: 0xFFi32 };
assert_eq!(error.to_string(), "0xff 0xFF");
}

78
tests/test_lints.rs
View file

@ -4,6 +4,17 @@ use thiserror::Error;
pub use std::error::Error;
#[test]
fn test_allow_attributes() {
#![deny(clippy::allow_attributes)]
#[derive(Error, Debug)]
#[error("...")]
pub struct MyError(#[from] anyhow::Error);
let _: MyError;
}
#[test]
fn test_unused_qualifications() {
#![deny(unused_qualifications)]
@ -12,9 +23,74 @@ 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;
let _: MyError;
}
#[test]
fn test_needless_lifetimes() {
#![allow(dead_code)]
#![deny(clippy::needless_lifetimes)]
#[derive(Error, Debug)]
#[error("...")]
pub enum MyError<'a> {
A(#[from] std::io::Error),
B(&'a ()),
}
let _: MyError;
}
#[test]
fn test_deprecated() {
#![deny(deprecated)]
#[derive(Error, Debug)]
#[deprecated]
#[error("...")]
pub struct DeprecatedStruct;
#[derive(Error, Debug)]
#[error("{message} {}", .message)]
pub struct DeprecatedStructField {
#[deprecated]
message: String,
}
#[derive(Error, Debug)]
#[deprecated]
pub enum DeprecatedEnum {
#[error("...")]
Variant,
}
#[derive(Error, Debug)]
pub enum DeprecatedVariant {
#[deprecated]
#[error("...")]
Variant,
}
#[derive(Error, Debug)]
pub enum DeprecatedFrom {
#[error(transparent)]
Variant(
#[from]
#[allow(deprecated)]
DeprecatedStruct,
),
}
#[allow(deprecated)]
let _: DeprecatedStruct;
#[allow(deprecated)]
let _: DeprecatedStructField;
#[allow(deprecated)]
let _ = DeprecatedEnum::Variant;
#[allow(deprecated)]
let _ = DeprecatedVariant::Variant;
}

1
tests/test_option.rs
View file

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

17
tests/test_path.rs
View file

@ -1,3 +1,5 @@
#![cfg(feature = "std")]
use core::fmt::Display;
use ref_cast::RefCast;
use std::path::{Path, PathBuf};
@ -22,6 +24,21 @@ enum EnumPathBuf {
Read(PathBuf),
}
#[derive(Error, Debug)]
#[error("{tail}")]
pub struct UnsizedError {
pub head: i32,
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<T: Display>(expected: &str, value: T) {
assert_eq!(expected, value.to_string());
}

17
tests/test_source.rs
View file

@ -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());
}

18
tests/test_transparent.rs
View file

@ -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)]

2
tests/ui/concat-display.stderr
View file

@ -1,4 +1,4 @@
error: expected string literal
error: expected one of: string literal, `transparent`, `fmt`
--> tests/ui/concat-display.rs:8:17
|
8 | #[error(concat!("invalid ", $what))]

7
tests/ui/display-underscore.rs Normal file
View file

@ -0,0 +1,7 @@
use thiserror::Error;
#[derive(Error, Debug)]
#[error("{_}")]
pub struct Error;
fn main() {}

7
tests/ui/display-underscore.stderr Normal file
View file

@ -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

15
tests/ui/duplicate-fmt.rs
View file

@ -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() {}

18
tests/ui/duplicate-fmt.stderr
View file

@ -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("...")]
| ^^^^^^^^^^^^^^^

7
tests/ui/expression-fallback.rs Normal file
View file

@ -0,0 +1,7 @@
use thiserror::Error;
#[derive(Error, Debug)]
#[error("".yellow)]
pub struct ArgError;
fn main() {}

19
tests/ui/expression-fallback.stderr Normal file
View file

@ -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

2
tests/ui/from-not-source.rs
View file

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

3
tests/ui/missing-display.stderr
View file

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

6
tests/ui/no-display.rs
View file

@ -9,4 +9,10 @@ pub struct Error {
thread: NoDisplay,
}
#[derive(Error, Debug)]
#[error("thread: {thread:o}")]
pub struct ErrorOctal {
thread: NoDisplay,
}
fn main() {}

26
tests/ui/no-display.stderr
View file

@ -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<T>
Saturating<T>
Wrapping<T>
i128
i16
i32
and $N others
= 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
|
| pub fn new_octal<T: 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)

7
tests/ui/numbered-positional-tuple.rs Normal file
View file

@ -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() {}

5
tests/ui/numbered-positional-tuple.stderr Normal file
View file

@ -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)]
| ^^^^^^^^

12
tests/ui/raw-identifier.rs Normal file
View file

@ -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}");
}

21
tests/ui/raw-identifier.stderr Normal file
View file

@ -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#`

11
tests/ui/same-from-type.rs Normal file
View file

@ -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() {}

8
tests/ui/same-from-type.stderr Normal file
View file

@ -0,0 +1,8 @@
error[E0119]: conflicting implementations of trait `From<std::io::Error>` for type `Error`
--> tests/ui/same-from-type.rs:8:15
|
6 | OpenFile(#[from] std::io::Error),
| ------- first implementation here
7 | #[error("failed to close")]
8 | CloseFile(#[from] std::io::Error),
| ^^^^^^^ conflicting implementation for `Error`

4
tests/ui/source-enum-unnamed-field-not-error.stderr
View file

@ -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`

4
tests/ui/source-struct-unnamed-field-not-error.stderr
View file

@ -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`

7
tests/ui/struct-with-fmt.rs Normal file
View file

@ -0,0 +1,7 @@
use thiserror::Error;
#[derive(Error, Debug)]
#[error(fmt = core::fmt::Octal::fmt)]
pub struct Error(i32);
fn main() {}

5
tests/ui/struct-with-fmt.stderr Normal file
View file

@ -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)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

9
tests/ui/unconditional-recursion.rs Normal file
View file

@ -0,0 +1,9 @@
use thiserror::Error;
#[derive(Error, Debug)]
#[error("{self}")]
pub struct Error;
fn main() {
__FAIL__;
}

21
tests/ui/unconditional-recursion.stderr Normal file
View file

@ -0,0 +1,21 @@
error[E0425]: cannot find value `__FAIL__` in this scope
--> tests/ui/unconditional-recursion.rs:8:5
|
8 | __FAIL__;
| ^^^^^^^^ not found in this scope
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}")]
| ^^^^^^^^