From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/thiserror/tests/compiletest.rs | 8 + vendor/thiserror/tests/test_backtrace.rs | 248 +++++++++++++++++++ vendor/thiserror/tests/test_display.rs | 274 +++++++++++++++++++++ vendor/thiserror/tests/test_error.rs | 57 +++++ vendor/thiserror/tests/test_expr.rs | 89 +++++++ vendor/thiserror/tests/test_from.rs | 64 +++++ vendor/thiserror/tests/test_generics.rs | 161 ++++++++++++ vendor/thiserror/tests/test_lints.rs | 18 ++ vendor/thiserror/tests/test_option.rs | 106 ++++++++ vendor/thiserror/tests/test_path.rs | 39 +++ vendor/thiserror/tests/test_source.rs | 67 +++++ vendor/thiserror/tests/test_transparent.rs | 80 ++++++ vendor/thiserror/tests/ui/bad-field-attr.rs | 7 + vendor/thiserror/tests/ui/bad-field-attr.stderr | 5 + vendor/thiserror/tests/ui/concat-display.rs | 15 ++ vendor/thiserror/tests/ui/concat-display.stderr | 10 + vendor/thiserror/tests/ui/duplicate-enum-source.rs | 13 + .../tests/ui/duplicate-enum-source.stderr | 5 + vendor/thiserror/tests/ui/duplicate-fmt.rs | 8 + vendor/thiserror/tests/ui/duplicate-fmt.stderr | 5 + .../thiserror/tests/ui/duplicate-struct-source.rs | 11 + .../tests/ui/duplicate-struct-source.stderr | 5 + vendor/thiserror/tests/ui/duplicate-transparent.rs | 8 + .../tests/ui/duplicate-transparent.stderr | 5 + vendor/thiserror/tests/ui/from-not-source.rs | 11 + vendor/thiserror/tests/ui/from-not-source.stderr | 5 + vendor/thiserror/tests/ui/lifetime.rs | 24 ++ vendor/thiserror/tests/ui/lifetime.stderr | 11 + vendor/thiserror/tests/ui/missing-fmt.rs | 10 + vendor/thiserror/tests/ui/missing-fmt.stderr | 5 + vendor/thiserror/tests/ui/no-display.rs | 12 + vendor/thiserror/tests/ui/no-display.stderr | 23 ++ vendor/thiserror/tests/ui/source-enum-not-error.rs | 14 ++ .../tests/ui/source-enum-not-error.stderr | 28 +++ .../thiserror/tests/ui/source-struct-not-error.rs | 12 + .../tests/ui/source-struct-not-error.stderr | 27 ++ vendor/thiserror/tests/ui/transparent-display.rs | 8 + .../thiserror/tests/ui/transparent-display.stderr | 5 + vendor/thiserror/tests/ui/transparent-enum-many.rs | 9 + .../tests/ui/transparent-enum-many.stderr | 6 + .../thiserror/tests/ui/transparent-enum-source.rs | 9 + .../tests/ui/transparent-enum-source.stderr | 5 + .../thiserror/tests/ui/transparent-struct-many.rs | 10 + .../tests/ui/transparent-struct-many.stderr | 5 + .../tests/ui/transparent-struct-source.rs | 7 + .../tests/ui/transparent-struct-source.stderr | 5 + vendor/thiserror/tests/ui/unexpected-field-fmt.rs | 11 + .../thiserror/tests/ui/unexpected-field-fmt.stderr | 5 + .../thiserror/tests/ui/unexpected-struct-source.rs | 7 + .../tests/ui/unexpected-struct-source.stderr | 5 + vendor/thiserror/tests/ui/union.rs | 9 + vendor/thiserror/tests/ui/union.stderr | 8 + 52 files changed, 1604 insertions(+) create mode 100644 vendor/thiserror/tests/compiletest.rs create mode 100644 vendor/thiserror/tests/test_backtrace.rs create mode 100644 vendor/thiserror/tests/test_display.rs create mode 100644 vendor/thiserror/tests/test_error.rs create mode 100644 vendor/thiserror/tests/test_expr.rs create mode 100644 vendor/thiserror/tests/test_from.rs create mode 100644 vendor/thiserror/tests/test_generics.rs create mode 100644 vendor/thiserror/tests/test_lints.rs create mode 100644 vendor/thiserror/tests/test_option.rs create mode 100644 vendor/thiserror/tests/test_path.rs create mode 100644 vendor/thiserror/tests/test_source.rs create mode 100644 vendor/thiserror/tests/test_transparent.rs create mode 100644 vendor/thiserror/tests/ui/bad-field-attr.rs create mode 100644 vendor/thiserror/tests/ui/bad-field-attr.stderr create mode 100644 vendor/thiserror/tests/ui/concat-display.rs create mode 100644 vendor/thiserror/tests/ui/concat-display.stderr create mode 100644 vendor/thiserror/tests/ui/duplicate-enum-source.rs create mode 100644 vendor/thiserror/tests/ui/duplicate-enum-source.stderr create mode 100644 vendor/thiserror/tests/ui/duplicate-fmt.rs create mode 100644 vendor/thiserror/tests/ui/duplicate-fmt.stderr create mode 100644 vendor/thiserror/tests/ui/duplicate-struct-source.rs create mode 100644 vendor/thiserror/tests/ui/duplicate-struct-source.stderr create mode 100644 vendor/thiserror/tests/ui/duplicate-transparent.rs create mode 100644 vendor/thiserror/tests/ui/duplicate-transparent.stderr create mode 100644 vendor/thiserror/tests/ui/from-not-source.rs create mode 100644 vendor/thiserror/tests/ui/from-not-source.stderr create mode 100644 vendor/thiserror/tests/ui/lifetime.rs create mode 100644 vendor/thiserror/tests/ui/lifetime.stderr create mode 100644 vendor/thiserror/tests/ui/missing-fmt.rs create mode 100644 vendor/thiserror/tests/ui/missing-fmt.stderr create mode 100644 vendor/thiserror/tests/ui/no-display.rs create mode 100644 vendor/thiserror/tests/ui/no-display.stderr create mode 100644 vendor/thiserror/tests/ui/source-enum-not-error.rs create mode 100644 vendor/thiserror/tests/ui/source-enum-not-error.stderr create mode 100644 vendor/thiserror/tests/ui/source-struct-not-error.rs create mode 100644 vendor/thiserror/tests/ui/source-struct-not-error.stderr create mode 100644 vendor/thiserror/tests/ui/transparent-display.rs create mode 100644 vendor/thiserror/tests/ui/transparent-display.stderr create mode 100644 vendor/thiserror/tests/ui/transparent-enum-many.rs create mode 100644 vendor/thiserror/tests/ui/transparent-enum-many.stderr create mode 100644 vendor/thiserror/tests/ui/transparent-enum-source.rs create mode 100644 vendor/thiserror/tests/ui/transparent-enum-source.stderr create mode 100644 vendor/thiserror/tests/ui/transparent-struct-many.rs create mode 100644 vendor/thiserror/tests/ui/transparent-struct-many.stderr create mode 100644 vendor/thiserror/tests/ui/transparent-struct-source.rs create mode 100644 vendor/thiserror/tests/ui/transparent-struct-source.stderr create mode 100644 vendor/thiserror/tests/ui/unexpected-field-fmt.rs create mode 100644 vendor/thiserror/tests/ui/unexpected-field-fmt.stderr create mode 100644 vendor/thiserror/tests/ui/unexpected-struct-source.rs create mode 100644 vendor/thiserror/tests/ui/unexpected-struct-source.stderr create mode 100644 vendor/thiserror/tests/ui/union.rs create mode 100644 vendor/thiserror/tests/ui/union.stderr (limited to 'vendor/thiserror/tests') diff --git a/vendor/thiserror/tests/compiletest.rs b/vendor/thiserror/tests/compiletest.rs new file mode 100644 index 000000000..641d03cbf --- /dev/null +++ b/vendor/thiserror/tests/compiletest.rs @@ -0,0 +1,8 @@ +#![deny(clippy::all, clippy::pedantic)] + +#[rustversion::attr(not(nightly), ignore)] +#[test] +fn ui() { + let t = trybuild::TestCases::new(); + t.compile_fail("tests/ui/*.rs"); +} diff --git a/vendor/thiserror/tests/test_backtrace.rs b/vendor/thiserror/tests/test_backtrace.rs new file mode 100644 index 000000000..42e37ca16 --- /dev/null +++ b/vendor/thiserror/tests/test_backtrace.rs @@ -0,0 +1,248 @@ +#![cfg_attr(thiserror_nightly_testing, feature(backtrace))] + +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("...")] +pub struct Inner; + +#[cfg(thiserror_nightly_testing)] +#[derive(Error, Debug)] +#[error("...")] +pub struct InnerBacktrace { + backtrace: std::backtrace::Backtrace, +} + +#[cfg(thiserror_nightly_testing)] +pub mod structs { + use super::{Inner, InnerBacktrace}; + use std::backtrace::Backtrace; + use std::error::Error; + use std::sync::Arc; + use thiserror::Error; + + #[derive(Error, Debug)] + #[error("...")] + pub struct PlainBacktrace { + backtrace: Backtrace, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct ExplicitBacktrace { + #[backtrace] + backtrace: Backtrace, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct OptBacktrace { + #[backtrace] + backtrace: Option, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct ArcBacktrace { + #[backtrace] + backtrace: Arc, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct BacktraceFrom { + #[from] + source: Inner, + #[backtrace] + backtrace: Backtrace, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct CombinedBacktraceFrom { + #[from] + #[backtrace] + source: InnerBacktrace, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct OptBacktraceFrom { + #[from] + source: Inner, + #[backtrace] + backtrace: Option, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct ArcBacktraceFrom { + #[from] + source: Inner, + #[backtrace] + backtrace: Arc, + } + + #[test] + fn test_backtrace() { + let error = PlainBacktrace { + backtrace: Backtrace::capture(), + }; + assert!(error.backtrace().is_some()); + + let error = ExplicitBacktrace { + backtrace: Backtrace::capture(), + }; + assert!(error.backtrace().is_some()); + + let error = OptBacktrace { + backtrace: Some(Backtrace::capture()), + }; + assert!(error.backtrace().is_some()); + + let error = ArcBacktrace { + backtrace: Arc::new(Backtrace::capture()), + }; + assert!(error.backtrace().is_some()); + + let error = BacktraceFrom::from(Inner); + assert!(error.backtrace().is_some()); + + let error = CombinedBacktraceFrom::from(InnerBacktrace { + backtrace: Backtrace::capture(), + }); + assert!(error.backtrace().is_some()); + + let error = OptBacktraceFrom::from(Inner); + assert!(error.backtrace().is_some()); + + let error = ArcBacktraceFrom::from(Inner); + assert!(error.backtrace().is_some()); + } +} + +#[cfg(thiserror_nightly_testing)] +pub mod enums { + use super::{Inner, InnerBacktrace}; + use std::backtrace::Backtrace; + use std::error::Error; + use std::sync::Arc; + use thiserror::Error; + + #[derive(Error, Debug)] + pub enum PlainBacktrace { + #[error("...")] + Test { backtrace: Backtrace }, + } + + #[derive(Error, Debug)] + pub enum ExplicitBacktrace { + #[error("...")] + Test { + #[backtrace] + backtrace: Backtrace, + }, + } + + #[derive(Error, Debug)] + pub enum OptBacktrace { + #[error("...")] + Test { + #[backtrace] + backtrace: Option, + }, + } + + #[derive(Error, Debug)] + pub enum ArcBacktrace { + #[error("...")] + Test { + #[backtrace] + backtrace: Arc, + }, + } + + #[derive(Error, Debug)] + pub enum BacktraceFrom { + #[error("...")] + Test { + #[from] + source: Inner, + #[backtrace] + backtrace: Backtrace, + }, + } + + #[derive(Error, Debug)] + pub enum CombinedBacktraceFrom { + #[error("...")] + Test { + #[from] + #[backtrace] + source: InnerBacktrace, + }, + } + + #[derive(Error, Debug)] + pub enum OptBacktraceFrom { + #[error("...")] + Test { + #[from] + source: Inner, + #[backtrace] + backtrace: Option, + }, + } + + #[derive(Error, Debug)] + pub enum ArcBacktraceFrom { + #[error("...")] + Test { + #[from] + source: Inner, + #[backtrace] + backtrace: Arc, + }, + } + + #[test] + fn test_backtrace() { + let error = PlainBacktrace::Test { + backtrace: Backtrace::capture(), + }; + assert!(error.backtrace().is_some()); + + let error = ExplicitBacktrace::Test { + backtrace: Backtrace::capture(), + }; + assert!(error.backtrace().is_some()); + + let error = OptBacktrace::Test { + backtrace: Some(Backtrace::capture()), + }; + assert!(error.backtrace().is_some()); + + let error = ArcBacktrace::Test { + backtrace: Arc::new(Backtrace::capture()), + }; + assert!(error.backtrace().is_some()); + + let error = BacktraceFrom::from(Inner); + assert!(error.backtrace().is_some()); + + let error = CombinedBacktraceFrom::from(InnerBacktrace { + backtrace: Backtrace::capture(), + }); + assert!(error.backtrace().is_some()); + + let error = OptBacktraceFrom::from(Inner); + assert!(error.backtrace().is_some()); + + let error = ArcBacktraceFrom::from(Inner); + assert!(error.backtrace().is_some()); + } +} + +#[test] +#[cfg_attr(not(thiserror_nightly_testing), ignore)] +fn test_backtrace() {} diff --git a/vendor/thiserror/tests/test_display.rs b/vendor/thiserror/tests/test_display.rs new file mode 100644 index 000000000..949d9eda7 --- /dev/null +++ b/vendor/thiserror/tests/test_display.rs @@ -0,0 +1,274 @@ +#![deny(clippy::all, clippy::pedantic)] + +use std::fmt::Display; +use thiserror::Error; + +fn assert(expected: &str, value: T) { + assert_eq!(expected, value.to_string()); +} + +#[test] +fn test_braced() { + #[derive(Error, Debug)] + #[error("braced error: {msg}")] + struct Error { + msg: String, + } + + let msg = "T".to_owned(); + assert("braced error: T", Error { msg }); +} + +#[test] +fn test_braced_unused() { + #[derive(Error, Debug)] + #[error("braced error")] + struct Error { + extra: usize, + } + + assert("braced error", Error { extra: 0 }); +} + +#[test] +fn test_tuple() { + #[derive(Error, Debug)] + #[error("tuple error: {0}")] + struct Error(usize); + + assert("tuple error: 0", Error(0)); +} + +#[test] +fn test_unit() { + #[derive(Error, Debug)] + #[error("unit error")] + struct Error; + + assert("unit error", Error); +} + +#[test] +fn test_enum() { + #[derive(Error, Debug)] + enum Error { + #[error("braced error: {id}")] + Braced { id: usize }, + #[error("tuple error: {0}")] + Tuple(usize), + #[error("unit error")] + Unit, + } + + assert("braced error: 0", Error::Braced { id: 0 }); + assert("tuple error: 0", Error::Tuple(0)); + assert("unit error", Error::Unit); +} + +#[test] +fn test_constants() { + #[derive(Error, Debug)] + #[error("{MSG}: {id:?} (code {CODE:?})")] + struct Error { + id: &'static str, + } + + const MSG: &str = "failed to do"; + const CODE: usize = 9; + + assert("failed to do: \"\" (code 9)", Error { id: "" }); +} + +#[test] +fn test_inherit() { + #[derive(Error, Debug)] + #[error("{0}")] + enum Error { + Some(&'static str), + #[error("other error")] + Other(&'static str), + } + + assert("some error", Error::Some("some error")); + assert("other error", Error::Other("...")); +} + +#[test] +fn test_brace_escape() { + #[derive(Error, Debug)] + #[error("fn main() {{}}")] + struct Error; + + assert("fn main() {}", Error); +} + +#[test] +fn test_expr() { + #[derive(Error, Debug)] + #[error("1 + 1 = {}", 1 + 1)] + struct Error; + assert("1 + 1 = 2", Error); +} + +#[test] +fn test_nested() { + #[derive(Error, Debug)] + #[error("!bool = {}", not(.0))] + struct Error(bool); + + #[allow(clippy::trivially_copy_pass_by_ref)] + fn not(bool: &bool) -> bool { + !*bool + } + + assert("!bool = false", Error(true)); +} + +#[test] +fn test_match() { + #[derive(Error, Debug)] + #[error("{}: {0}", match .1 { + Some(n) => format!("error occurred with {}", n), + None => "there was an empty error".to_owned(), + })] + struct Error(String, Option); + + assert( + "error occurred with 1: ...", + Error("...".to_owned(), Some(1)), + ); + assert( + "there was an empty error: ...", + Error("...".to_owned(), None), + ); +} + +#[test] +fn test_void() { + #[allow(clippy::empty_enum)] + #[derive(Error, Debug)] + #[error("...")] + pub enum Error {} + + let _: Error; +} + +#[test] +fn test_mixed() { + #[derive(Error, Debug)] + #[error("a={a} :: b={} :: c={c} :: d={d}", 1, c = 2, d = 3)] + struct Error { + a: usize, + d: usize, + } + + assert("a=0 :: b=1 :: c=2 :: d=3", Error { a: 0, d: 0 }); +} + +#[test] +fn test_ints() { + #[derive(Error, Debug)] + enum Error { + #[error("error {0}")] + Tuple(usize, usize), + #[error("error {0}", '?')] + Struct { v: usize }, + } + + assert("error 9", Error::Tuple(9, 0)); + assert("error ?", Error::Struct { v: 0 }); +} + +#[test] +fn test_trailing_comma() { + #[derive(Error, Debug)] + #[error( + "error {0}", + )] + #[rustfmt::skip] + struct Error(char); + + assert("error ?", Error('?')); +} + +#[test] +fn test_field() { + #[derive(Debug)] + struct Inner { + data: usize, + } + + #[derive(Error, Debug)] + #[error("{}", .0.data)] + struct Error(Inner); + + assert("0", Error(Inner { data: 0 })); +} + +#[test] +fn test_macro_rules() { + // Regression test for https://github.com/dtolnay/thiserror/issues/86 + + macro_rules! decl_error { + ($variant:ident($value:ident)) => { + #[derive(Debug, Error)] + pub enum Error0 { + #[error("{0:?}")] + $variant($value), + } + + #[derive(Debug, Error)] + #[error("{0:?}")] + pub enum Error1 { + $variant($value), + } + }; + } + + decl_error!(Repro(u8)); + + assert("0", Error0::Repro(0)); + assert("0", Error1::Repro(0)); +} + +#[test] +fn test_raw() { + #[derive(Error, Debug)] + #[error("braced raw error: {r#fn}")] + struct Error { + r#fn: &'static str, + } + + assert("braced raw error: T", Error { r#fn: "T" }); +} + +#[test] +fn test_raw_enum() { + #[derive(Error, Debug)] + enum Error { + #[error("braced raw error: {r#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)] + #[error("error: {type}", type = 1)] + struct Error; + + assert("error: 1", Error); +} diff --git a/vendor/thiserror/tests/test_error.rs b/vendor/thiserror/tests/test_error.rs new file mode 100644 index 000000000..ece7f91a9 --- /dev/null +++ b/vendor/thiserror/tests/test_error.rs @@ -0,0 +1,57 @@ +#![deny(clippy::all, clippy::pedantic)] +#![allow(dead_code)] + +use std::fmt::{self, Display}; +use std::io; +use thiserror::Error; + +macro_rules! unimplemented_display { + ($ty:ty) => { + impl Display for $ty { + fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result { + unimplemented!() + } + } + }; +} + +#[derive(Error, Debug)] +struct BracedError { + msg: String, + pos: usize, +} + +#[derive(Error, Debug)] +struct TupleError(String, usize); + +#[derive(Error, Debug)] +struct UnitError; + +#[derive(Error, Debug)] +struct WithSource { + #[source] + cause: io::Error, +} + +#[derive(Error, Debug)] +struct WithAnyhow { + #[source] + cause: anyhow::Error, +} + +#[derive(Error, Debug)] +enum EnumError { + Braced { + #[source] + cause: io::Error, + }, + Tuple(#[source] io::Error), + Unit, +} + +unimplemented_display!(BracedError); +unimplemented_display!(TupleError); +unimplemented_display!(UnitError); +unimplemented_display!(WithSource); +unimplemented_display!(WithAnyhow); +unimplemented_display!(EnumError); diff --git a/vendor/thiserror/tests/test_expr.rs b/vendor/thiserror/tests/test_expr.rs new file mode 100644 index 000000000..87a56cf58 --- /dev/null +++ b/vendor/thiserror/tests/test_expr.rs @@ -0,0 +1,89 @@ +#![deny(clippy::all, clippy::pedantic)] +#![allow(clippy::option_if_let_else)] + +use std::fmt::Display; +use thiserror::Error; + +// Some of the elaborate cases from the rcc codebase, which is a C compiler in +// Rust. https://github.com/jyn514/rcc/blob/0.8.0/src/data/error.rs +#[derive(Error, Debug)] +pub enum CompilerError { + #[error("cannot shift {} by {maximum} or more bits (got {current})", if *.is_left { "left" } else { "right" })] + TooManyShiftBits { + is_left: bool, + maximum: u64, + current: u64, + }, + + #[error("#error {}", (.0).iter().copied().collect::>().join(" "))] + User(Vec<&'static str>), + + #[error("overflow while parsing {}integer literal", + if let Some(signed) = .is_signed { + if *signed { "signed "} else { "unsigned "} + } else { + "" + } + )] + IntegerOverflow { is_signed: Option }, + + #[error("overflow while parsing {}integer literal", match .is_signed { + Some(true) => "signed ", + Some(false) => "unsigned ", + None => "", + })] + IntegerOverflow2 { is_signed: Option }, +} + +// Examples drawn from Rustup. +#[derive(Error, Debug)] +pub enum RustupError { + #[error( + "toolchain '{name}' does not contain component {component}{}", + .suggestion + .as_ref() + .map_or_else(String::new, |s| format!("; did you mean '{}'?", s)), + )] + UnknownComponent { + name: String, + component: String, + suggestion: Option, + }, +} + +fn assert(expected: &str, value: T) { + assert_eq!(expected, value.to_string()); +} + +#[test] +fn test_rcc() { + assert( + "cannot shift left by 32 or more bits (got 50)", + CompilerError::TooManyShiftBits { + is_left: true, + maximum: 32, + current: 50, + }, + ); + + assert("#error A B C", CompilerError::User(vec!["A", "B", "C"])); + + assert( + "overflow while parsing signed integer literal", + CompilerError::IntegerOverflow { + is_signed: Some(true), + }, + ); +} + +#[test] +fn test_rustup() { + assert( + "toolchain 'nightly' does not contain component clipy; did you mean 'clippy'?", + RustupError::UnknownComponent { + name: "nightly".to_owned(), + component: "clipy".to_owned(), + suggestion: Some("clippy".to_owned()), + }, + ); +} diff --git a/vendor/thiserror/tests/test_from.rs b/vendor/thiserror/tests/test_from.rs new file mode 100644 index 000000000..a25ce353d --- /dev/null +++ b/vendor/thiserror/tests/test_from.rs @@ -0,0 +1,64 @@ +#![deny(clippy::all, clippy::pedantic)] + +use std::io; +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("...")] +pub struct ErrorStruct { + #[from] + source: io::Error, +} + +#[derive(Error, Debug)] +#[error("...")] +pub struct ErrorStructOptional { + #[from] + source: Option, +} + +#[derive(Error, Debug)] +#[error("...")] +pub struct ErrorTuple(#[from] io::Error); + +#[derive(Error, Debug)] +#[error("...")] +pub struct ErrorTupleOptional(#[from] Option); + +#[derive(Error, Debug)] +#[error("...")] +pub enum ErrorEnum { + Test { + #[from] + source: io::Error, + }, +} + +#[derive(Error, Debug)] +#[error("...")] +pub enum ErrorEnumOptional { + Test { + #[from] + source: Option, + }, +} + +#[derive(Error, Debug)] +#[error("...")] +pub enum Many { + Any(#[from] anyhow::Error), + Io(#[from] io::Error), +} + +fn assert_impl>() {} + +#[test] +fn test_from() { + assert_impl::(); + assert_impl::(); + assert_impl::(); + assert_impl::(); + assert_impl::(); + assert_impl::(); + assert_impl::(); +} diff --git a/vendor/thiserror/tests/test_generics.rs b/vendor/thiserror/tests/test_generics.rs new file mode 100644 index 000000000..f5e1de243 --- /dev/null +++ b/vendor/thiserror/tests/test_generics.rs @@ -0,0 +1,161 @@ +#![deny(clippy::all, clippy::pedantic)] + +use std::fmt::{self, Debug, Display}; +use thiserror::Error; + +pub struct NoFormat; + +#[derive(Debug)] +pub struct DebugOnly; + +pub struct DisplayOnly; + +impl Display for DisplayOnly { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str("display only") + } +} + +#[derive(Debug)] +pub struct DebugAndDisplay; + +impl Display for DebugAndDisplay { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str("debug and display") + } +} + +// Should expand to: +// +// impl Display for EnumDebugField +// where +// E: Debug; +// +// impl Error for EnumDebugField +// where +// Self: Debug + Display; +// +#[derive(Error, Debug)] +pub enum EnumDebugGeneric { + #[error("{0:?}")] + FatalError(E), +} + +// Should expand to: +// +// impl Display for EnumFromGeneric; +// +// impl Error for EnumFromGeneric +// where +// EnumDebugGeneric: Error + 'static, +// Self: Debug + Display; +// +#[derive(Error, Debug)] +pub enum EnumFromGeneric { + #[error("enum from generic")] + Source(#[from] EnumDebugGeneric), +} + +// Should expand to: +// +// impl Display +// for EnumCompound +// where +// HasDisplay: Display, +// HasDebug: Debug; +// +// impl Error +// for EnumCompound +// where +// Self: Debug + Display; +// +#[derive(Error)] +pub enum EnumCompound { + #[error("{0} {1:?}")] + DisplayDebug(HasDisplay, HasDebug), + #[error("{0}")] + Display(HasDisplay, HasNeither), + #[error("{1:?}")] + Debug(HasNeither, HasDebug), +} + +impl Debug for EnumCompound { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str("EnumCompound") + } +} + +#[test] +fn test_display_enum_compound() { + let mut instance: EnumCompound; + + instance = EnumCompound::DisplayDebug(DisplayOnly, DebugOnly); + assert_eq!(format!("{}", instance), "display only DebugOnly"); + + instance = EnumCompound::Display(DisplayOnly, NoFormat); + assert_eq!(format!("{}", instance), "display only"); + + instance = EnumCompound::Debug(NoFormat, DebugOnly); + assert_eq!(format!("{}", instance), "DebugOnly"); +} + +// Should expand to: +// +// impl Display for EnumTransparentGeneric +// where +// E: Display; +// +// impl Error for EnumTransparentGeneric +// where +// E: Error, +// Self: Debug + Display; +// +#[derive(Error, Debug)] +pub enum EnumTransparentGeneric { + #[error(transparent)] + Other(E), +} + +// Should expand to: +// +// impl Display for StructDebugGeneric +// where +// E: Debug; +// +// impl Error for StructDebugGeneric +// where +// Self: Debug + Display; +// +#[derive(Error, Debug)] +#[error("{underlying:?}")] +pub struct StructDebugGeneric { + pub underlying: E, +} + +// Should expand to: +// +// impl Error for StructFromGeneric +// where +// StructDebugGeneric: Error + 'static, +// Self: Debug + Display; +// +#[derive(Error, Debug)] +pub struct StructFromGeneric { + #[from] + pub source: StructDebugGeneric, +} + +// Should expand to: +// +// impl Display for StructTransparentGeneric +// where +// E: Display; +// +// impl Error for StructTransparentGeneric +// where +// E: Error, +// Self: Debug + Display; +// +#[derive(Error, Debug)] +#[error(transparent)] +pub struct StructTransparentGeneric(E); diff --git a/vendor/thiserror/tests/test_lints.rs b/vendor/thiserror/tests/test_lints.rs new file mode 100644 index 000000000..59699a4a3 --- /dev/null +++ b/vendor/thiserror/tests/test_lints.rs @@ -0,0 +1,18 @@ +use thiserror::Error; + +pub use std::error::Error; + +#[test] +fn test_unused_qualifications() { + #![deny(unused_qualifications)] + + // Expansion of derive(Error) macro can't know whether something like + // std::error::Error is already imported in the caller's scope so it must + // suppress unused_qualifications. + + #[derive(Debug, Error)] + #[error("...")] + pub struct MyError; + + let _: MyError; +} diff --git a/vendor/thiserror/tests/test_option.rs b/vendor/thiserror/tests/test_option.rs new file mode 100644 index 000000000..ca2171385 --- /dev/null +++ b/vendor/thiserror/tests/test_option.rs @@ -0,0 +1,106 @@ +#![cfg_attr(thiserror_nightly_testing, feature(backtrace))] +#![deny(clippy::all, clippy::pedantic)] + +#[cfg(thiserror_nightly_testing)] +pub mod structs { + use std::backtrace::Backtrace; + use thiserror::Error; + + #[derive(Error, Debug)] + #[error("...")] + pub struct OptSourceNoBacktrace { + #[source] + source: Option, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct OptSourceAlwaysBacktrace { + #[source] + source: Option, + backtrace: Backtrace, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct NoSourceOptBacktrace { + #[backtrace] + backtrace: Option, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct AlwaysSourceOptBacktrace { + source: anyhow::Error, + #[backtrace] + backtrace: Option, + } + + #[derive(Error, Debug)] + #[error("...")] + pub struct OptSourceOptBacktrace { + #[source] + source: Option, + #[backtrace] + backtrace: Option, + } +} + +#[cfg(thiserror_nightly_testing)] +pub mod enums { + use std::backtrace::Backtrace; + use thiserror::Error; + + #[derive(Error, Debug)] + pub enum OptSourceNoBacktrace { + #[error("...")] + Test { + #[source] + source: Option, + }, + } + + #[derive(Error, Debug)] + pub enum OptSourceAlwaysBacktrace { + #[error("...")] + Test { + #[source] + source: Option, + backtrace: Backtrace, + }, + } + + #[derive(Error, Debug)] + pub enum NoSourceOptBacktrace { + #[error("...")] + Test { + #[backtrace] + backtrace: Option, + }, + } + + #[derive(Error, Debug)] + pub enum AlwaysSourceOptBacktrace { + #[error("...")] + Test { + source: anyhow::Error, + #[backtrace] + backtrace: Option, + }, + } + + #[derive(Error, Debug)] + pub enum OptSourceOptBacktrace { + #[error("...")] + Test { + #[source] + source: Option, + #[backtrace] + backtrace: Option, + }, + } +} + +#[test] +#[cfg_attr(not(thiserror_nightly_testing), ignore)] +fn test_option() {} diff --git a/vendor/thiserror/tests/test_path.rs b/vendor/thiserror/tests/test_path.rs new file mode 100644 index 000000000..a10b1f342 --- /dev/null +++ b/vendor/thiserror/tests/test_path.rs @@ -0,0 +1,39 @@ +#![deny(clippy::all, clippy::pedantic)] + +use ref_cast::RefCast; +use std::fmt::Display; +use std::path::{Path, PathBuf}; +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("failed to read '{file}'")] +struct StructPathBuf { + file: PathBuf, +} + +#[derive(Error, Debug, RefCast)] +#[repr(C)] +#[error("failed to read '{file}'")] +struct StructPath { + file: Path, +} + +#[derive(Error, Debug)] +enum EnumPathBuf { + #[error("failed to read '{0}'")] + Read(PathBuf), +} + +fn assert(expected: &str, value: T) { + assert_eq!(expected, value.to_string()); +} + +#[test] +fn test_display() { + let path = Path::new("/thiserror"); + let file = path.to_owned(); + assert("failed to read '/thiserror'", StructPathBuf { file }); + let file = path.to_owned(); + assert("failed to read '/thiserror'", EnumPathBuf::Read(file)); + assert("failed to read '/thiserror'", StructPath::ref_cast(path)); +} diff --git a/vendor/thiserror/tests/test_source.rs b/vendor/thiserror/tests/test_source.rs new file mode 100644 index 000000000..ab16097b2 --- /dev/null +++ b/vendor/thiserror/tests/test_source.rs @@ -0,0 +1,67 @@ +#![deny(clippy::all, clippy::pedantic)] + +use std::error::Error as StdError; +use std::io; +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("implicit source")] +pub struct ImplicitSource { + source: io::Error, +} + +#[derive(Error, Debug)] +#[error("explicit source")] +pub struct ExplicitSource { + source: String, + #[source] + io: io::Error, +} + +#[derive(Error, Debug)] +#[error("boxed source")] +pub struct BoxedSource { + #[source] + source: Box, +} + +#[test] +fn test_implicit_source() { + let io = io::Error::new(io::ErrorKind::Other, "oh no!"); + let error = ImplicitSource { source: io }; + error.source().unwrap().downcast_ref::().unwrap(); +} + +#[test] +fn test_explicit_source() { + let io = io::Error::new(io::ErrorKind::Other, "oh no!"); + let error = ExplicitSource { + source: String::new(), + io, + }; + error.source().unwrap().downcast_ref::().unwrap(); +} + +#[test] +fn test_boxed_source() { + let source = Box::new(io::Error::new(io::ErrorKind::Other, "oh no!")); + let error = BoxedSource { source }; + error.source().unwrap().downcast_ref::().unwrap(); +} + +macro_rules! error_from_macro { + ($($variants:tt)*) => { + #[derive(Error)] + #[derive(Debug)] + pub enum MacroSource { + $($variants)* + } + } +} + +// Test that we generate impls with the proper hygiene +#[rustfmt::skip] +error_from_macro! { + #[error("Something")] + Variant(#[from] io::Error) +} diff --git a/vendor/thiserror/tests/test_transparent.rs b/vendor/thiserror/tests/test_transparent.rs new file mode 100644 index 000000000..84d7c9189 --- /dev/null +++ b/vendor/thiserror/tests/test_transparent.rs @@ -0,0 +1,80 @@ +#![deny(clippy::all, clippy::pedantic)] + +use anyhow::anyhow; +use std::error::Error as _; +use std::io; +use thiserror::Error; + +#[test] +fn test_transparent_struct() { + #[derive(Error, Debug)] + #[error(transparent)] + struct Error(ErrorKind); + + #[derive(Error, Debug)] + enum ErrorKind { + #[error("E0")] + E0, + #[error("E1")] + E1(#[from] io::Error), + } + + let error = Error(ErrorKind::E0); + assert_eq!("E0", error.to_string()); + assert!(error.source().is_none()); + + let io = io::Error::new(io::ErrorKind::Other, "oh no!"); + let error = Error(ErrorKind::from(io)); + assert_eq!("E1", error.to_string()); + error.source().unwrap().downcast_ref::().unwrap(); +} + +#[test] +fn test_transparent_enum() { + #[derive(Error, Debug)] + enum Error { + #[error("this failed")] + This, + #[error(transparent)] + Other(anyhow::Error), + } + + let error = Error::This; + assert_eq!("this failed", 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)] + #[error(transparent)] + struct Any(#[from] anyhow::Error); + + let error = Any::from(anyhow!("inner").context("outer")); + assert_eq!("outer", error.to_string()); + assert_eq!("inner", error.source().unwrap().to_string()); +} + +#[test] +fn test_non_static() { + #[derive(Error, Debug)] + #[error(transparent)] + struct Error<'a> { + inner: ErrorKind<'a>, + } + + #[derive(Error, Debug)] + enum ErrorKind<'a> { + #[error("unexpected token: {:?}", token)] + Unexpected { token: &'a str }, + } + + let error = Error { + inner: ErrorKind::Unexpected { token: "error" }, + }; + assert_eq!("unexpected token: \"error\"", error.to_string()); + assert!(error.source().is_none()); +} diff --git a/vendor/thiserror/tests/ui/bad-field-attr.rs b/vendor/thiserror/tests/ui/bad-field-attr.rs new file mode 100644 index 000000000..d5429b2b2 --- /dev/null +++ b/vendor/thiserror/tests/ui/bad-field-attr.rs @@ -0,0 +1,7 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error(transparent)] +pub struct Error(#[error(transparent)] std::io::Error); + +fn main() {} diff --git a/vendor/thiserror/tests/ui/bad-field-attr.stderr b/vendor/thiserror/tests/ui/bad-field-attr.stderr new file mode 100644 index 000000000..5fb574415 --- /dev/null +++ b/vendor/thiserror/tests/ui/bad-field-attr.stderr @@ -0,0 +1,5 @@ +error: #[error(transparent)] needs to go outside the enum or struct, not on an individual field + --> tests/ui/bad-field-attr.rs:5:18 + | +5 | pub struct Error(#[error(transparent)] std::io::Error); + | ^^^^^^^^^^^^^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/concat-display.rs b/vendor/thiserror/tests/ui/concat-display.rs new file mode 100644 index 000000000..8b53cc0cd --- /dev/null +++ b/vendor/thiserror/tests/ui/concat-display.rs @@ -0,0 +1,15 @@ +use thiserror::Error; + +macro_rules! error_type { + ($name:ident, $what:expr) => { + // Use #[error("invalid {}", $what)] instead. + + #[derive(Error, Debug)] + #[error(concat!("invalid ", $what))] + pub struct $name; + }; +} + +error_type!(Error, "foo"); + +fn main() {} diff --git a/vendor/thiserror/tests/ui/concat-display.stderr b/vendor/thiserror/tests/ui/concat-display.stderr new file mode 100644 index 000000000..6ab40481f --- /dev/null +++ b/vendor/thiserror/tests/ui/concat-display.stderr @@ -0,0 +1,10 @@ +error: expected string literal + --> tests/ui/concat-display.rs:8:17 + | +8 | #[error(concat!("invalid ", $what))] + | ^^^^^^ +... +13 | error_type!(Error, "foo"); + | -------------------------- in this macro invocation + | + = note: this error originates in the macro `error_type` (in Nightly builds, run with -Z macro-backtrace for more info) diff --git a/vendor/thiserror/tests/ui/duplicate-enum-source.rs b/vendor/thiserror/tests/ui/duplicate-enum-source.rs new file mode 100644 index 000000000..15e579f8f --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-enum-source.rs @@ -0,0 +1,13 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum ErrorEnum { + Confusing { + #[source] + a: std::io::Error, + #[source] + b: anyhow::Error, + }, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/duplicate-enum-source.stderr b/vendor/thiserror/tests/ui/duplicate-enum-source.stderr new file mode 100644 index 000000000..4a4b2d398 --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-enum-source.stderr @@ -0,0 +1,5 @@ +error: duplicate #[source] attribute + --> tests/ui/duplicate-enum-source.rs:8:9 + | +8 | #[source] + | ^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/duplicate-fmt.rs b/vendor/thiserror/tests/ui/duplicate-fmt.rs new file mode 100644 index 000000000..cb3d67881 --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-fmt.rs @@ -0,0 +1,8 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("...")] +#[error("...")] +pub struct Error; + +fn main() {} diff --git a/vendor/thiserror/tests/ui/duplicate-fmt.stderr b/vendor/thiserror/tests/ui/duplicate-fmt.stderr new file mode 100644 index 000000000..532b16bdb --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-fmt.stderr @@ -0,0 +1,5 @@ +error: only one #[error(...)] attribute is allowed + --> tests/ui/duplicate-fmt.rs:5:1 + | +5 | #[error("...")] + | ^^^^^^^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/duplicate-struct-source.rs b/vendor/thiserror/tests/ui/duplicate-struct-source.rs new file mode 100644 index 000000000..569df8dd4 --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-struct-source.rs @@ -0,0 +1,11 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +pub struct ErrorStruct { + #[source] + a: std::io::Error, + #[source] + b: anyhow::Error, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/duplicate-struct-source.stderr b/vendor/thiserror/tests/ui/duplicate-struct-source.stderr new file mode 100644 index 000000000..c8de5747d --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-struct-source.stderr @@ -0,0 +1,5 @@ +error: duplicate #[source] attribute + --> tests/ui/duplicate-struct-source.rs:7:5 + | +7 | #[source] + | ^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/duplicate-transparent.rs b/vendor/thiserror/tests/ui/duplicate-transparent.rs new file mode 100644 index 000000000..49c0e4667 --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-transparent.rs @@ -0,0 +1,8 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error(transparent)] +#[error(transparent)] +pub struct Error(anyhow::Error); + +fn main() {} diff --git a/vendor/thiserror/tests/ui/duplicate-transparent.stderr b/vendor/thiserror/tests/ui/duplicate-transparent.stderr new file mode 100644 index 000000000..a8308790e --- /dev/null +++ b/vendor/thiserror/tests/ui/duplicate-transparent.stderr @@ -0,0 +1,5 @@ +error: duplicate #[error(transparent)] attribute + --> tests/ui/duplicate-transparent.rs:5:1 + | +5 | #[error(transparent)] + | ^^^^^^^^^^^^^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/from-not-source.rs b/vendor/thiserror/tests/ui/from-not-source.rs new file mode 100644 index 000000000..d1855bec5 --- /dev/null +++ b/vendor/thiserror/tests/ui/from-not-source.rs @@ -0,0 +1,11 @@ +use thiserror::Error; + +#[derive(Debug, Error)] +pub struct Error { + #[source] + source: std::io::Error, + #[from] + other: anyhow::Error, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/from-not-source.stderr b/vendor/thiserror/tests/ui/from-not-source.stderr new file mode 100644 index 000000000..97136017d --- /dev/null +++ b/vendor/thiserror/tests/ui/from-not-source.stderr @@ -0,0 +1,5 @@ +error: #[from] is only supported on the source field, not any other field + --> tests/ui/from-not-source.rs:7:5 + | +7 | #[from] + | ^^^^^^^ diff --git a/vendor/thiserror/tests/ui/lifetime.rs b/vendor/thiserror/tests/ui/lifetime.rs new file mode 100644 index 000000000..698f8c4e8 --- /dev/null +++ b/vendor/thiserror/tests/ui/lifetime.rs @@ -0,0 +1,24 @@ +use std::fmt::Debug; +use thiserror::Error; + +#[derive(Error, Debug)] +#[error("error")] +struct Error<'a>(#[from] Inner<'a>); + +#[derive(Error, Debug)] +#[error("{0}")] +struct Inner<'a>(&'a str); + +#[derive(Error, Debug)] +enum Enum<'a> { + #[error("error")] + Foo(#[from] Generic<&'a str>), +} + +#[derive(Error, Debug)] +#[error("{0:?}")] +struct Generic(T); + +fn main() -> Result<(), Error<'static>> { + Err(Error(Inner("some text"))) +} diff --git a/vendor/thiserror/tests/ui/lifetime.stderr b/vendor/thiserror/tests/ui/lifetime.stderr new file mode 100644 index 000000000..8b58136e5 --- /dev/null +++ b/vendor/thiserror/tests/ui/lifetime.stderr @@ -0,0 +1,11 @@ +error: non-static lifetimes are not allowed in the source of an error, because std::error::Error requires the source is dyn Error + 'static + --> tests/ui/lifetime.rs:6:26 + | +6 | struct Error<'a>(#[from] Inner<'a>); + | ^^^^^^^^^ + +error: non-static lifetimes are not allowed in the source of an error, because std::error::Error requires the source is dyn Error + 'static + --> tests/ui/lifetime.rs:15:17 + | +15 | Foo(#[from] Generic<&'a str>), + | ^^^^^^^^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/missing-fmt.rs b/vendor/thiserror/tests/ui/missing-fmt.rs new file mode 100644 index 000000000..d52fbdf0d --- /dev/null +++ b/vendor/thiserror/tests/ui/missing-fmt.rs @@ -0,0 +1,10 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum Error { + #[error("...")] + A(usize), + B(usize), +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/missing-fmt.stderr b/vendor/thiserror/tests/ui/missing-fmt.stderr new file mode 100644 index 000000000..c0be37357 --- /dev/null +++ b/vendor/thiserror/tests/ui/missing-fmt.stderr @@ -0,0 +1,5 @@ +error: missing #[error("...")] display attribute + --> tests/ui/missing-fmt.rs:7:5 + | +7 | B(usize), + | ^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/no-display.rs b/vendor/thiserror/tests/ui/no-display.rs new file mode 100644 index 000000000..181a66e02 --- /dev/null +++ b/vendor/thiserror/tests/ui/no-display.rs @@ -0,0 +1,12 @@ +use thiserror::Error; + +#[derive(Debug)] +struct NoDisplay; + +#[derive(Error, Debug)] +#[error("thread: {thread}")] +pub struct Error { + thread: NoDisplay, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/no-display.stderr b/vendor/thiserror/tests/ui/no-display.stderr new file mode 100644 index 000000000..e6a52f5e7 --- /dev/null +++ b/vendor/thiserror/tests/ui/no-display.stderr @@ -0,0 +1,23 @@ +error[E0599]: the method `as_display` exists for reference `&NoDisplay`, but its trait bounds were not satisfied + --> tests/ui/no-display.rs:7:9 + | +4 | struct NoDisplay; + | ----------------- doesn't satisfy `NoDisplay: std::fmt::Display` +... +7 | #[error("thread: {thread}")] + | ^^^^^^^^^^^^^^^^^^ method cannot be called on `&NoDisplay` due to unsatisfied trait bounds + | + = note: the following trait bounds were not satisfied: + `NoDisplay: std::fmt::Display` + which is required by `&NoDisplay: DisplayAsDisplay` +note: the following trait must be implemented + --> $RUST/core/src/fmt/mod.rs + | + | / pub trait Display { + | | /// Formats the value using the given formatter. + | | /// + | | /// # Examples +... | + | | fn fmt(&self, f: &mut Formatter<'_>) -> Result; + | | } + | |_^ diff --git a/vendor/thiserror/tests/ui/source-enum-not-error.rs b/vendor/thiserror/tests/ui/source-enum-not-error.rs new file mode 100644 index 000000000..3eb0d3e86 --- /dev/null +++ b/vendor/thiserror/tests/ui/source-enum-not-error.rs @@ -0,0 +1,14 @@ +use thiserror::Error; + +#[derive(Debug)] +pub struct NotError; + +#[derive(Error, Debug)] +#[error("...")] +pub enum ErrorEnum { + Broken { + source: NotError, + }, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/source-enum-not-error.stderr b/vendor/thiserror/tests/ui/source-enum-not-error.stderr new file mode 100644 index 000000000..d01cba5b0 --- /dev/null +++ b/vendor/thiserror/tests/ui/source-enum-not-error.stderr @@ -0,0 +1,28 @@ +error[E0599]: the method `as_dyn_error` exists for reference `&NotError`, but its trait bounds were not satisfied + --> tests/ui/source-enum-not-error.rs:10:9 + | +4 | pub struct NotError; + | -------------------- + | | + | doesn't satisfy `NotError: AsDynError` + | doesn't satisfy `NotError: std::error::Error` +... +10 | source: NotError, + | ^^^^^^ method cannot be called on `&NotError` due to unsatisfied trait bounds + | + = note: the following trait bounds were not satisfied: + `NotError: std::error::Error` + which is required by `NotError: AsDynError` + `&NotError: std::error::Error` + which is required by `&NotError: AsDynError` +note: the following trait must be implemented + --> $RUST/std/src/error.rs + | + | / pub trait Error: Debug + Display { + | | /// The lower-level source of this error, if any. + | | /// + | | /// # Examples +... | + | | } + | | } + | |_^ diff --git a/vendor/thiserror/tests/ui/source-struct-not-error.rs b/vendor/thiserror/tests/ui/source-struct-not-error.rs new file mode 100644 index 000000000..d59df1eef --- /dev/null +++ b/vendor/thiserror/tests/ui/source-struct-not-error.rs @@ -0,0 +1,12 @@ +use thiserror::Error; + +#[derive(Debug)] +struct NotError; + +#[derive(Error, Debug)] +#[error("...")] +pub struct ErrorStruct { + source: NotError, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/source-struct-not-error.stderr b/vendor/thiserror/tests/ui/source-struct-not-error.stderr new file mode 100644 index 000000000..be1331a50 --- /dev/null +++ b/vendor/thiserror/tests/ui/source-struct-not-error.stderr @@ -0,0 +1,27 @@ +error[E0599]: the method `as_dyn_error` exists for struct `NotError`, but its trait bounds were not satisfied + --> tests/ui/source-struct-not-error.rs:9:5 + | +4 | struct NotError; + | ---------------- + | | + | method `as_dyn_error` not found for this + | doesn't satisfy `NotError: AsDynError` + | doesn't satisfy `NotError: std::error::Error` +... +9 | source: NotError, + | ^^^^^^ method cannot be called on `NotError` due to unsatisfied trait bounds + | + = note: the following trait bounds were not satisfied: + `NotError: std::error::Error` + which is required by `NotError: AsDynError` +note: the following trait must be implemented + --> $RUST/std/src/error.rs + | + | / pub trait Error: Debug + Display { + | | /// The lower-level source of this error, if any. + | | /// + | | /// # Examples +... | + | | } + | | } + | |_^ diff --git a/vendor/thiserror/tests/ui/transparent-display.rs b/vendor/thiserror/tests/ui/transparent-display.rs new file mode 100644 index 000000000..2a59f183b --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-display.rs @@ -0,0 +1,8 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error(transparent)] +#[error("...")] +pub struct Error(anyhow::Error); + +fn main() {} diff --git a/vendor/thiserror/tests/ui/transparent-display.stderr b/vendor/thiserror/tests/ui/transparent-display.stderr new file mode 100644 index 000000000..54d958b27 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-display.stderr @@ -0,0 +1,5 @@ +error: cannot have both #[error(transparent)] and a display attribute + --> tests/ui/transparent-display.rs:5:1 + | +5 | #[error("...")] + | ^^^^^^^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/transparent-enum-many.rs b/vendor/thiserror/tests/ui/transparent-enum-many.rs new file mode 100644 index 000000000..e2a73a470 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-enum-many.rs @@ -0,0 +1,9 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum Error { + #[error(transparent)] + Other(anyhow::Error, String), +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/transparent-enum-many.stderr b/vendor/thiserror/tests/ui/transparent-enum-many.stderr new file mode 100644 index 000000000..a9adfa5a9 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-enum-many.stderr @@ -0,0 +1,6 @@ +error: #[error(transparent)] requires exactly one field + --> tests/ui/transparent-enum-many.rs:5:5 + | +5 | / #[error(transparent)] +6 | | Other(anyhow::Error, String), + | |________________________________^ diff --git a/vendor/thiserror/tests/ui/transparent-enum-source.rs b/vendor/thiserror/tests/ui/transparent-enum-source.rs new file mode 100644 index 000000000..3849f66e7 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-enum-source.rs @@ -0,0 +1,9 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum Error { + #[error(transparent)] + Other(#[source] anyhow::Error), +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/transparent-enum-source.stderr b/vendor/thiserror/tests/ui/transparent-enum-source.stderr new file mode 100644 index 000000000..ccb906776 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-enum-source.stderr @@ -0,0 +1,5 @@ +error: transparent variant can't contain #[source] + --> tests/ui/transparent-enum-source.rs:6:11 + | +6 | Other(#[source] anyhow::Error), + | ^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/transparent-struct-many.rs b/vendor/thiserror/tests/ui/transparent-struct-many.rs new file mode 100644 index 000000000..18f246645 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-struct-many.rs @@ -0,0 +1,10 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error(transparent)] +pub struct Error { + inner: anyhow::Error, + what: String, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/transparent-struct-many.stderr b/vendor/thiserror/tests/ui/transparent-struct-many.stderr new file mode 100644 index 000000000..c0e3806e7 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-struct-many.stderr @@ -0,0 +1,5 @@ +error: #[error(transparent)] requires exactly one field + --> tests/ui/transparent-struct-many.rs:4:1 + | +4 | #[error(transparent)] + | ^^^^^^^^^^^^^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/transparent-struct-source.rs b/vendor/thiserror/tests/ui/transparent-struct-source.rs new file mode 100644 index 000000000..d4512c288 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-struct-source.rs @@ -0,0 +1,7 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[error(transparent)] +pub struct Error(#[source] anyhow::Error); + +fn main() {} diff --git a/vendor/thiserror/tests/ui/transparent-struct-source.stderr b/vendor/thiserror/tests/ui/transparent-struct-source.stderr new file mode 100644 index 000000000..3012ca311 --- /dev/null +++ b/vendor/thiserror/tests/ui/transparent-struct-source.stderr @@ -0,0 +1,5 @@ +error: transparent error struct can't contain #[source] + --> tests/ui/transparent-struct-source.rs:5:18 + | +5 | pub struct Error(#[source] anyhow::Error); + | ^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/unexpected-field-fmt.rs b/vendor/thiserror/tests/ui/unexpected-field-fmt.rs new file mode 100644 index 000000000..7c439d941 --- /dev/null +++ b/vendor/thiserror/tests/ui/unexpected-field-fmt.rs @@ -0,0 +1,11 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +pub enum Error { + What { + #[error("...")] + io: std::io::Error, + }, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/unexpected-field-fmt.stderr b/vendor/thiserror/tests/ui/unexpected-field-fmt.stderr new file mode 100644 index 000000000..bf3c24df2 --- /dev/null +++ b/vendor/thiserror/tests/ui/unexpected-field-fmt.stderr @@ -0,0 +1,5 @@ +error: not expected here; the #[error(...)] attribute belongs on top of a struct or an enum variant + --> tests/ui/unexpected-field-fmt.rs:6:9 + | +6 | #[error("...")] + | ^^^^^^^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/unexpected-struct-source.rs b/vendor/thiserror/tests/ui/unexpected-struct-source.rs new file mode 100644 index 000000000..f39649424 --- /dev/null +++ b/vendor/thiserror/tests/ui/unexpected-struct-source.rs @@ -0,0 +1,7 @@ +use thiserror::Error; + +#[derive(Error, Debug)] +#[source] +pub struct Error; + +fn main() {} diff --git a/vendor/thiserror/tests/ui/unexpected-struct-source.stderr b/vendor/thiserror/tests/ui/unexpected-struct-source.stderr new file mode 100644 index 000000000..6f15841dc --- /dev/null +++ b/vendor/thiserror/tests/ui/unexpected-struct-source.stderr @@ -0,0 +1,5 @@ +error: not expected here; the #[source] attribute belongs on a specific field + --> tests/ui/unexpected-struct-source.rs:4:1 + | +4 | #[source] + | ^^^^^^^^^ diff --git a/vendor/thiserror/tests/ui/union.rs b/vendor/thiserror/tests/ui/union.rs new file mode 100644 index 000000000..cd6a9346d --- /dev/null +++ b/vendor/thiserror/tests/ui/union.rs @@ -0,0 +1,9 @@ +use thiserror::Error; + +#[derive(Error)] +pub union U { + msg: &'static str, + num: usize, +} + +fn main() {} diff --git a/vendor/thiserror/tests/ui/union.stderr b/vendor/thiserror/tests/ui/union.stderr new file mode 100644 index 000000000..3ec4d71c0 --- /dev/null +++ b/vendor/thiserror/tests/ui/union.stderr @@ -0,0 +1,8 @@ +error: union as errors are not supported + --> tests/ui/union.rs:4:1 + | +4 | / pub union U { +5 | | msg: &'static str, +6 | | num: usize, +7 | | } + | |_^ -- cgit v1.2.3