From 319bf301d4dec98fce07a07c238c50ca4651d596 Mon Sep 17 00:00:00 2001 From: Roman Titov Date: Sat, 29 Feb 2020 20:32:08 +0100 Subject: [PATCH] Remove backtrace forwarding support --- src/error.rs | 95 +----- ...or_enums_with_source_backtrace_chaining.rs | 285 ----------------- ...ic_enums_with_source_backtrace_chaining.rs | 289 ------------------ ..._structs_with_source_backtrace_chaining.rs | 245 --------------- ..._structs_with_source_backtrace_chaining.rs | 241 --------------- tests/error/nightly/mod.rs | 4 - 6 files changed, 8 insertions(+), 1151 deletions(-) delete mode 100644 tests/error/nightly/derives_for_enums_with_source_backtrace_chaining.rs delete mode 100644 tests/error/nightly/derives_for_generic_enums_with_source_backtrace_chaining.rs delete mode 100644 tests/error/nightly/derives_for_generic_structs_with_source_backtrace_chaining.rs delete mode 100644 tests/error/nightly/derives_for_structs_with_source_backtrace_chaining.rs diff --git a/src/error.rs b/src/error.rs index 24a33163..911b3265 100644 --- a/src/error.rs +++ b/src/error.rs @@ -205,96 +205,17 @@ impl<'input, 'state> ParsedFields<'input, 'state> { } fn render_backtrace_as_struct(&self) -> Option { - self.render_backtrace_impl( - |fields, index| { - let expr = &fields.data.members[index]; - quote!(#expr) - }, - |fields, index| { - let expr = &fields.data.members[index]; - quote!(&#expr) - }, - false, - ) - .map(|(_, expr)| expr) + self.backtrace.map(|backtrace| { + let backtrace_expr = &self.data.members[backtrace]; + quote!(Some(&#backtrace_expr)) + }) } fn render_backtrace_as_enum_variant_match_arm(&self) -> Option { - self.render_backtrace_impl( - |_, _| quote!(source), - |_, _| quote!(backtrace), - true, - ) - .map(|(pattern, expr)| quote!(#pattern => #expr)) - } - - fn render_backtrace_impl( - &self, - source_expr: S, - backtrace_expr: B, - is_rendering_enum_match_arm: bool, - ) -> Option<(TokenStream, TokenStream)> - where - S: Fn(&ParsedFields, usize) -> TokenStream, - B: Fn(&ParsedFields, usize) -> TokenStream, - { - if !cfg!(feature = "nightly") { - return None; - } - - // Disable proxying call to `backtrace` to `source` if - // `source` explicitly marked with `#[error(not(backtrace))]`. - let source = self.source.and_then(|source| { - match self.data.infos[source].info.backtrace { - Some(false) => None, - _ => Some(source), - } - }); - - let mut indices = Vec::new(); - let mut bindings = Vec::new(); - - let mut bind = |index: usize, binding: &TokenStream| { - if is_rendering_enum_match_arm { - indices.push(index); - bindings.push(binding.clone()); - } - }; - - let expr = match (source, self.backtrace) { - (Some(source), backtrace) => { - let source_expr = source_expr(self, source); - bind(source, &source_expr); - - let backtrace_expr = backtrace - .filter(|backtrace| source != *backtrace) - .map(|backtrace| { - let backtrace_expr = backtrace_expr(self, backtrace); - bind(backtrace, &backtrace_expr); - - quote!(.or_else(|| Some(#backtrace_expr))) - }); - - quote!(#source_expr.backtrace()#backtrace_expr) - } - - (None, Some(backtrace)) => { - let backtrace_expr = backtrace_expr(self, backtrace); - bind(backtrace, &backtrace_expr); - - quote!(Some(#backtrace_expr)) - } - - _ => return None, - }; - - let pattern = if is_rendering_enum_match_arm { - self.data.matcher(&indices, &bindings) - } else { - TokenStream::new() - }; - - Some((pattern, expr)) + self.backtrace.map(|backtrace| { + let pattern = self.data.matcher(&[backtrace], &[quote!(backtrace)]); + quote!(#pattern => Some(backtrace)) + }) } } diff --git a/tests/error/nightly/derives_for_enums_with_source_backtrace_chaining.rs b/tests/error/nightly/derives_for_enums_with_source_backtrace_chaining.rs deleted file mode 100644 index df18e49f..00000000 --- a/tests/error/nightly/derives_for_enums_with_source_backtrace_chaining.rs +++ /dev/null @@ -1,285 +0,0 @@ -use super::*; - -derive_display!(TestErr); -#[derive(Debug, Error)] -enum TestErr { - NamedNoBacktraceNoSource { - field: i32, - }, - NamedNoBacktraceSourceWithoutBacktrace { - source: SimpleErr, - field: i32, - }, - NamedNoBacktraceSourceWithBacktraceExplicitlyDisabled { - #[error(not(backtrace))] - source: BacktraceErr, - field: i32, - }, - NamedNoBacktraceSourceWithBacktrace { - source: BacktraceErr, - field: i32, - }, - NamedBacktraceNoSource { - backtrace: Backtrace, - field: i32, - }, - NamedBacktraceSourceWithoutBacktrace { - source: SimpleErr, - backtrace: Backtrace, - field: i32, - }, - NamedBacktraceSourceWithBacktraceExplicitlyDisabled { - #[error(not(backtrace))] - source: BacktraceErr, - backtrace: Backtrace, - field: i32, - }, - NamedBacktraceSourceWithBacktrace { - source: BacktraceErr, - backtrace: Backtrace, - field: i32, - }, - UnnamedNoBacktraceNoSource(i32, i32), - UnnamedNoBacktraceSourceWithoutBacktrace(#[error(source)] SimpleErr, i32), - UnnamedNoBacktraceSourceWithBacktraceExplicitlyDisabled( - #[error(source, not(backtrace))] BacktraceErr, - i32, - ), - UnnamedNoBacktraceSourceWithBacktrace(#[error(source)] BacktraceErr, i32), - UnnamedBacktraceNoSource(Backtrace, i32, i32), - UnnamedBacktraceSourceWithoutBacktrace(#[error(source)] SimpleErr, Backtrace, i32), - UnnamedBacktraceSourceWithBacktraceExplictilyDisabled( - #[error(source, not(backtrace))] BacktraceErr, - Backtrace, - i32, - ), - UnnamedBacktraceSourceWithBacktrace(#[error(source)] BacktraceErr, Backtrace, i32), - UnnamedBacktraceImplicitSourceWithoutBacktrace(SimpleErr, Backtrace), - UnnamedBacktraceImplicitSourceWithBacktraceExplicitlyDisabled( - #[error(not(backtrace))] BacktraceErr, - Backtrace, - ), - UnnamedBacktraceImplicitSourceWithBacktrace(BacktraceErr, Backtrace), -} - -impl TestErr { - fn get_stored_backtrace(&self) -> &Backtrace { - match self { - Self::NamedBacktraceSourceWithoutBacktrace { backtrace, .. } => backtrace, - Self::NamedBacktraceSourceWithBacktraceExplicitlyDisabled { - backtrace, - .. - } => backtrace, - Self::NamedBacktraceSourceWithBacktrace { backtrace, .. } => backtrace, - Self::UnnamedBacktraceSourceWithoutBacktrace(_, backtrace, _) => backtrace, - Self::UnnamedBacktraceSourceWithBacktraceExplictilyDisabled( - _, - backtrace, - _, - ) => backtrace, - Self::UnnamedBacktraceSourceWithBacktrace(_, backtrace, _) => backtrace, - Self::UnnamedBacktraceImplicitSourceWithoutBacktrace(_, backtrace) => { - backtrace - } - Self::UnnamedBacktraceImplicitSourceWithBacktraceExplicitlyDisabled( - _, - backtrace, - ) => backtrace, - Self::UnnamedBacktraceImplicitSourceWithBacktrace(_, backtrace) => { - backtrace - } - _ => panic!("ERROR IN TEST IMPLEMENTATION"), - } - } -} - -#[test] -fn named_no_backtrace_no_source() { - let err = TestErr::NamedNoBacktraceNoSource { field: 0 }; - - assert!(err.backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_without_backtrace() { - let err = TestErr::NamedNoBacktraceSourceWithoutBacktrace { - source: SimpleErr, - field: 0, - }; - - assert!(err.backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_with_backtrace_explicitly_disabled() { - let err = TestErr::NamedNoBacktraceSourceWithBacktraceExplicitlyDisabled { - source: BacktraceErr::default(), - field: 0, - }; - - assert!(err.backtrace().is_none()); -} - -#[test] -fn named_no_backtrace_source_with_backtrace() { - let err = TestErr::NamedNoBacktraceSourceWithBacktrace { - source: BacktraceErr::default(), - field: 0, - }; - - assert!(err.backtrace().is_some()); -} - -#[test] -fn named_backtrace_no_source() { - let err = TestErr::NamedBacktraceNoSource { - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); -} - -#[test] -fn named_backtrace_source_without_backtrace() { - let err = TestErr::NamedBacktraceSourceWithoutBacktrace { - source: SimpleErr, - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn named_backtrace_source_with_backtrace_explicitly_disabled() { - let err = TestErr::NamedBacktraceSourceWithBacktraceExplicitlyDisabled { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn named_backtrace_source_with_backtrace() { - let err = TestErr::NamedBacktraceSourceWithBacktrace { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_no_backtrace_no_source() { - let err = TestErr::UnnamedNoBacktraceNoSource(0, 0); - - assert!(err.backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_without_backtrace() { - let err = TestErr::UnnamedNoBacktraceSourceWithoutBacktrace(SimpleErr, 0); - - assert!(err.backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace_explicitly_disabled() { - let err = TestErr::UnnamedNoBacktraceSourceWithBacktraceExplicitlyDisabled( - BacktraceErr::default(), - 0, - ); - - assert!(err.backtrace().is_none()); -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace() { - let err = - TestErr::UnnamedNoBacktraceSourceWithBacktrace(BacktraceErr::default(), 0); - - assert!(err.backtrace().is_some()); -} - -#[test] -fn unnamed_backtrace_no_source() { - let err = TestErr::UnnamedBacktraceNoSource(Backtrace::force_capture(), 0, 0); - - assert!(err.backtrace().is_some()); -} - -#[test] -fn unnamed_backtrace_source_without_backtrace() { - let err = TestErr::UnnamedBacktraceSourceWithoutBacktrace( - SimpleErr, - Backtrace::force_capture(), - 0, - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace_explictily_disabled() { - let err = TestErr::UnnamedBacktraceSourceWithBacktraceExplictilyDisabled( - BacktraceErr::default(), - Backtrace::force_capture(), - 0, - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace() { - let err = TestErr::UnnamedBacktraceSourceWithBacktrace( - BacktraceErr::default(), - Backtrace::force_capture(), - 0, - ); - - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_implicit_source_without_backtrace() { - let err = TestErr::UnnamedBacktraceImplicitSourceWithoutBacktrace( - SimpleErr, - Backtrace::force_capture(), - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace_explicitly_disabled() { - let err = TestErr::UnnamedBacktraceImplicitSourceWithBacktraceExplicitlyDisabled( - BacktraceErr::default(), - Backtrace::force_capture(), - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace() { - let err = TestErr::UnnamedBacktraceImplicitSourceWithBacktrace( - BacktraceErr::default(), - Backtrace::force_capture(), - ); - - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, .get_stored_backtrace); -} diff --git a/tests/error/nightly/derives_for_generic_enums_with_source_backtrace_chaining.rs b/tests/error/nightly/derives_for_generic_enums_with_source_backtrace_chaining.rs deleted file mode 100644 index e7e7bd04..00000000 --- a/tests/error/nightly/derives_for_generic_enums_with_source_backtrace_chaining.rs +++ /dev/null @@ -1,289 +0,0 @@ -use super::*; - -derive_display!(TestErr, E, T); -#[derive(Debug, Error)] -enum TestErr { - NamedNoBacktraceNoSource { - field: T, - }, - NamedNoBacktraceSourceWithoutBacktrace { - source: E, - field: T, - }, - NamedNoBacktraceSourceWithBacktraceExplicitlyDisabled { - #[error(not(backtrace))] - source: E, - field: T, - }, - NamedNoBacktraceSourceWithBacktrace { - source: E, - field: T, - }, - NamedBacktraceNoSource { - backtrace: Backtrace, - field: T, - }, - NamedBacktraceSourceWithoutBacktrace { - source: E, - backtrace: Backtrace, - field: T, - }, - NamedBacktraceSourceWithBacktraceExplicitlyDisabled { - #[error(not(backtrace))] - source: E, - backtrace: Backtrace, - field: T, - }, - NamedBacktraceSourceWithBacktrace { - source: E, - backtrace: Backtrace, - field: T, - }, - UnnamedNoBacktraceNoSource(T, T), - UnnamedNoBacktraceSourceWithoutBacktrace(#[error(source)] E, T), - UnnamedNoBacktraceSourceWithBacktraceExplicitlyDisabled( - #[error(source, not(backtrace))] E, - T, - ), - UnnamedNoBacktraceSourceWithBacktrace(#[error(source)] E, T), - UnnamedBacktraceNoSource(Backtrace, T, T), - UnnamedBacktraceSourceWithoutBacktrace(#[error(source)] E, Backtrace, T), - UnnamedBacktraceSourceWithBacktraceExplictilyDisabled( - #[error(source, not(backtrace))] E, - Backtrace, - T, - ), - UnnamedBacktraceSourceWithBacktrace(#[error(source)] E, Backtrace, T), - UnnamedBacktraceImplicitSourceWithoutBacktrace(E, Backtrace), - UnnamedBacktraceImplicitSourceWithBacktraceExplicitlyDisabled( - #[error(not(backtrace))] E, - Backtrace, - ), - UnnamedBacktraceImplicitSourceWithBacktrace(E, Backtrace), -} - -impl TestErr { - fn get_stored_backtrace(&self) -> &Backtrace { - match self { - Self::NamedBacktraceSourceWithoutBacktrace { backtrace, .. } => backtrace, - Self::NamedBacktraceSourceWithBacktraceExplicitlyDisabled { - backtrace, - .. - } => backtrace, - Self::NamedBacktraceSourceWithBacktrace { backtrace, .. } => backtrace, - Self::UnnamedBacktraceSourceWithoutBacktrace(_, backtrace, _) => backtrace, - Self::UnnamedBacktraceSourceWithBacktraceExplictilyDisabled( - _, - backtrace, - _, - ) => backtrace, - Self::UnnamedBacktraceSourceWithBacktrace(_, backtrace, _) => backtrace, - Self::UnnamedBacktraceImplicitSourceWithoutBacktrace(_, backtrace) => { - backtrace - } - Self::UnnamedBacktraceImplicitSourceWithBacktraceExplicitlyDisabled( - _, - backtrace, - ) => backtrace, - Self::UnnamedBacktraceImplicitSourceWithBacktrace(_, backtrace) => { - backtrace - } - _ => panic!("ERROR IN TEST IMPLEMENTATION"), - } - } -} - -#[test] -fn named_no_backtrace_no_source() { - let err = TestErr::::NamedNoBacktraceNoSource { field: 0 }; - - assert!(err.backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_without_backtrace() { - let err = TestErr::NamedNoBacktraceSourceWithoutBacktrace { - source: SimpleErr, - field: 0, - }; - - assert!(err.backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_with_backtrace_explicitly_disabled() { - let err = TestErr::NamedNoBacktraceSourceWithBacktraceExplicitlyDisabled { - source: BacktraceErr::default(), - field: 0, - }; - - assert!(err.backtrace().is_none()); -} - -#[test] -fn named_no_backtrace_source_with_backtrace() { - let err = TestErr::NamedNoBacktraceSourceWithBacktrace { - source: BacktraceErr::default(), - field: 0, - }; - - assert!(err.backtrace().is_some()); -} - -#[test] -fn named_backtrace_no_source() { - let err = TestErr::::NamedBacktraceNoSource { - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); -} - -#[test] -fn named_backtrace_source_without_backtrace() { - let err = TestErr::NamedBacktraceSourceWithoutBacktrace { - source: SimpleErr, - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn named_backtrace_source_with_backtrace_explicitly_disabled() { - let err = TestErr::NamedBacktraceSourceWithBacktraceExplicitlyDisabled { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn named_backtrace_source_with_backtrace() { - let err = TestErr::NamedBacktraceSourceWithBacktrace { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_no_backtrace_no_source() { - let err = TestErr::::UnnamedNoBacktraceNoSource(0, 0); - - assert!(err.backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_without_backtrace() { - let err = TestErr::UnnamedNoBacktraceSourceWithoutBacktrace(SimpleErr, 0); - - assert!(err.backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace_explicitly_disabled() { - let err = TestErr::UnnamedNoBacktraceSourceWithBacktraceExplicitlyDisabled( - BacktraceErr::default(), - 0, - ); - - assert!(err.backtrace().is_none()); -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace() { - let err = - TestErr::UnnamedNoBacktraceSourceWithBacktrace(BacktraceErr::default(), 0); - - assert!(err.backtrace().is_some()); -} - -#[test] -fn unnamed_backtrace_no_source() { - let err = TestErr::::UnnamedBacktraceNoSource( - Backtrace::force_capture(), - 0, - 0, - ); - - assert!(err.backtrace().is_some()); -} - -#[test] -fn unnamed_backtrace_source_without_backtrace() { - let err = TestErr::UnnamedBacktraceSourceWithoutBacktrace( - SimpleErr, - Backtrace::force_capture(), - 0, - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace_explictily_disabled() { - let err = TestErr::UnnamedBacktraceSourceWithBacktraceExplictilyDisabled( - BacktraceErr::default(), - Backtrace::force_capture(), - 0, - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace() { - let err = TestErr::UnnamedBacktraceSourceWithBacktrace( - BacktraceErr::default(), - Backtrace::force_capture(), - 0, - ); - - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_implicit_source_without_backtrace() { - let err = TestErr::<_, i32>::UnnamedBacktraceImplicitSourceWithoutBacktrace( - SimpleErr, - Backtrace::force_capture(), - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace_explicitly_disabled() { - let err = TestErr::<_, i32>::UnnamedBacktraceImplicitSourceWithBacktraceExplicitlyDisabled( - BacktraceErr::default(), - Backtrace::force_capture(), - ); - - assert!(err.backtrace().is_some()); - assert_bt!(==, err, .get_stored_backtrace); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace() { - let err = TestErr::<_, i32>::UnnamedBacktraceImplicitSourceWithBacktrace( - BacktraceErr::default(), - Backtrace::force_capture(), - ); - - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, .get_stored_backtrace); -} diff --git a/tests/error/nightly/derives_for_generic_structs_with_source_backtrace_chaining.rs b/tests/error/nightly/derives_for_generic_structs_with_source_backtrace_chaining.rs deleted file mode 100644 index 19fd9acb..00000000 --- a/tests/error/nightly/derives_for_generic_structs_with_source_backtrace_chaining.rs +++ /dev/null @@ -1,245 +0,0 @@ -use super::*; - -#[test] -fn named_no_backtrace_no_source() { - derive_display!(TestErr, T); - #[derive(Default, Debug, Error)] - struct TestErr { - field: T, - } - - assert!(TestErr::::default().backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_without_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Default, Debug, Error)] - struct TestErr { - source: E, - field: T, - } - - assert!(TestErr::::default().backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr, E, T); - #[derive(Default, Debug, Error)] - struct TestErr { - #[error(not(backtrace))] - source: E, - field: T, - } - - assert!(TestErr::::default() - .backtrace() - .is_none()); -} - -#[test] -fn named_no_backtrace_source_with_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Default, Debug, Error)] - struct TestErr { - source: E, - field: T, - } - - assert!(TestErr::::default() - .backtrace() - .is_some()); -} - -#[test] -fn named_backtrace_no_source() { - derive_display!(TestErr, T); - #[derive(Debug, Error)] - struct TestErr { - backtrace: Backtrace, - field: T, - } - - assert!(TestErr { - backtrace: Backtrace::force_capture(), - field: 0 - } - .backtrace() - .is_some()); -} - -#[test] -fn named_backtrace_source_without_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Debug, Error)] - struct TestErr { - source: E, - backtrace: Backtrace, - field: T, - } - - let err = TestErr { - source: SimpleErr, - backtrace: Backtrace::force_capture(), - field: 0, - }; - assert!(err.backtrace().is_some()); - assert_bt!(==, err); -} - -#[test] -fn named_backtrace_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr, E, T); - #[derive(Debug, Error)] - struct TestErr { - #[error(not(backtrace))] - source: E, - backtrace: Backtrace, - field: T, - } - - let err = TestErr { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - assert!(err.backtrace().is_some()); - assert_bt!(==, err); -} - -#[test] -fn named_backtrace_source_with_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Debug, Error)] - struct TestErr { - source: E, - backtrace: Backtrace, - field: T, - } - - let err = TestErr { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - assert!(err.backtrace().is_some()); - assert_bt!(!=, err); -} - -#[test] -fn unnamed_no_backtrace_no_source() { - derive_display!(TestErr, T); - #[derive(Default, Debug, Error)] - struct TestErr(T, T); - - assert!(TestErr::::default().backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_without_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Default, Debug, Error)] - struct TestErr(#[error(source)] E, T); - - assert!(TestErr::::default().backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr, E, T); - #[derive(Default, Debug, Error)] - struct TestErr(#[error(source, not(backtrace))] E, T); - - assert!(TestErr::::default() - .backtrace() - .is_none()); -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Default, Debug, Error)] - struct TestErr(#[error(source)] E, T); - - assert!(TestErr::::default() - .backtrace() - .is_some()); -} - -#[test] -fn unnamed_backtrace_no_source() { - derive_display!(TestErr, T); - #[derive(Debug, Error)] - struct TestErr(Backtrace, T, T); - - assert!(TestErr(Backtrace::force_capture(), 0, 0) - .backtrace() - .is_some()); -} - -#[test] -fn unnamed_backtrace_source_without_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Debug, Error)] - struct TestErr(#[error(source)] E, Backtrace, T); - - let err = TestErr(SimpleErr, Backtrace::force_capture(), 0); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace_explictitly_disabled() { - derive_display!(TestErr, E, T); - #[derive(Debug, Error)] - struct TestErr(#[error(source, not(backtrace))] E, Backtrace, T); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture(), 0); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace() { - derive_display!(TestErr, E, T); - #[derive(Debug, Error)] - struct TestErr(#[error(source)] E, Backtrace, T); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture(), 0); - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, 1); -} - -#[test] -fn unnamed_backtrace_implicit_source_without_backtrace() { - derive_display!(TestErr, E); - #[derive(Debug, Error)] - struct TestErr(E, Backtrace); - - let err = TestErr(SimpleErr, Backtrace::force_capture()); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr, E); - #[derive(Debug, Error)] - struct TestErr(#[error(not(backtrace))] E, Backtrace); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture()); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace() { - derive_display!(TestErr, E); - #[derive(Debug, Error)] - struct TestErr(E, Backtrace); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture()); - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, 1); -} diff --git a/tests/error/nightly/derives_for_structs_with_source_backtrace_chaining.rs b/tests/error/nightly/derives_for_structs_with_source_backtrace_chaining.rs deleted file mode 100644 index 489224c9..00000000 --- a/tests/error/nightly/derives_for_structs_with_source_backtrace_chaining.rs +++ /dev/null @@ -1,241 +0,0 @@ -use super::*; - -#[test] -fn named_no_backtrace_no_source() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr { - field: i32, - } - - assert!(TestErr::default().backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_without_backtrace() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr { - source: SimpleErr, - field: i32, - } - - assert!(TestErr::default().backtrace().is_none()) -} - -#[test] -fn named_no_backtrace_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr { - #[error(not(backtrace))] - source: BacktraceErr, - field: i32, - } - - assert!(TestErr::default().backtrace().is_none()); -} - -#[test] -fn named_no_backtrace_source_with_backtrace() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr { - source: BacktraceErr, - field: i32, - } - - assert!(TestErr::default().backtrace().is_some()); -} - -#[test] -fn named_backtrace_no_source() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr { - backtrace: Backtrace, - field: i32, - } - - assert!(TestErr { - backtrace: Backtrace::force_capture(), - field: 0 - } - .backtrace() - .is_some()); -} - -#[test] -fn named_backtrace_source_without_backtrace() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr { - source: SimpleErr, - backtrace: Backtrace, - field: i32, - } - - let err = TestErr { - source: SimpleErr, - backtrace: Backtrace::force_capture(), - field: 0, - }; - assert!(err.backtrace().is_some()); - assert_bt!(==, err); -} - -#[test] -fn named_backtrace_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr { - #[error(not(backtrace))] - source: BacktraceErr, - backtrace: Backtrace, - field: i32, - } - - let err = TestErr { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - assert!(err.backtrace().is_some()); - assert_bt!(==, err); -} - -#[test] -fn named_backtrace_source_with_backtrace() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr { - source: BacktraceErr, - backtrace: Backtrace, - field: i32, - } - - let err = TestErr { - source: BacktraceErr::default(), - backtrace: Backtrace::force_capture(), - field: 0, - }; - assert!(err.backtrace().is_some()); - assert_bt!(!=, err); -} - -#[test] -fn unnamed_no_backtrace_no_source() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr(i32, i32); - - assert!(TestErr::default().backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_without_backtrace() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr(#[error(source)] SimpleErr, i32); - - assert!(TestErr::default().backtrace().is_none()) -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr(#[error(source, not(backtrace))] BacktraceErr, i32); - - assert!(TestErr::default().backtrace().is_none()); -} - -#[test] -fn unnamed_no_backtrace_source_with_backtrace() { - derive_display!(TestErr); - #[derive(Default, Debug, Error)] - struct TestErr(#[error(source)] BacktraceErr, i32); - - assert!(TestErr::default().backtrace().is_some()); -} - -#[test] -fn unnamed_backtrace_no_source() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr(Backtrace, i32, i32); - - assert!(TestErr(Backtrace::force_capture(), 0, 0) - .backtrace() - .is_some()); -} - -#[test] -fn unnamed_backtrace_source_without_backtrace() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr(#[error(source)] SimpleErr, Backtrace, i32); - - let err = TestErr(SimpleErr, Backtrace::force_capture(), 0); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace_explictily_disabled() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr( - #[error(source, not(backtrace))] BacktraceErr, - Backtrace, - i32, - ); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture(), 0); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_source_with_backtrace() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr(#[error(source)] BacktraceErr, Backtrace, i32); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture(), 0); - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, 1); -} - -#[test] -fn unnamed_backtrace_implicit_source_without_backtrace() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr(SimpleErr, Backtrace); - - let err = TestErr(SimpleErr, Backtrace::force_capture()); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace_explicitly_disabled() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr(#[error(not(backtrace))] BacktraceErr, Backtrace); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture()); - assert!(err.backtrace().is_some()); - assert_bt!(==, err, 1); -} - -#[test] -fn unnamed_backtrace_implicit_source_with_backtrace() { - derive_display!(TestErr); - #[derive(Debug, Error)] - struct TestErr(BacktraceErr, Backtrace); - - let err = TestErr(BacktraceErr::default(), Backtrace::force_capture()); - assert!(err.backtrace().is_some()); - assert_bt!(!=, err, 1); -} diff --git a/tests/error/nightly/mod.rs b/tests/error/nightly/mod.rs index edb55271..57de7ba2 100644 --- a/tests/error/nightly/mod.rs +++ b/tests/error/nightly/mod.rs @@ -60,13 +60,9 @@ macro_rules! assert_bt { } mod derives_for_enums_with_backtrace; -mod derives_for_enums_with_source_backtrace_chaining; mod derives_for_generic_enums_with_backtrace; -mod derives_for_generic_enums_with_source_backtrace_chaining; mod derives_for_generic_structs_with_backtrace; -mod derives_for_generic_structs_with_source_backtrace_chaining; mod derives_for_structs_with_backtrace; -mod derives_for_structs_with_source_backtrace_chaining; derive_display!(BacktraceErr); #[derive(Debug)]