From b2bbca393384c6d7e343decef5a927e16f003038 Mon Sep 17 00:00:00 2001 From: Jane Losare-Lusby Date: Mon, 18 Jul 2022 17:52:03 +0000 Subject: [PATCH] remove fn backtrace --- library/std/src/error.rs | 74 +++++++++++++++------------------- library/std/src/error/tests.rs | 5 ++- 2 files changed, 36 insertions(+), 43 deletions(-) diff --git a/library/std/src/error.rs b/library/std/src/error.rs index ff7b70c328daf..722df119d2294 100644 --- a/library/std/src/error.rs +++ b/library/std/src/error.rs @@ -260,20 +260,6 @@ pub trait Error: Debug + Display { TypeId::of::() } - /// Returns a stack backtrace, if available, of where this error occurred. - /// - /// This function allows inspecting the location, in code, of where an error - /// happened. The returned `Backtrace` contains information about the stack - /// trace of the OS thread of execution of where the error originated from. - /// - /// Note that not all errors contain a `Backtrace`. Also note that a - /// `Backtrace` may actually be empty. For more information consult the - /// `Backtrace` type itself. - #[unstable(feature = "backtrace", issue = "53487")] - fn backtrace(&self) -> Option<&Backtrace> { - None - } - /// ``` /// if let Err(e) = "xc".parse::() { /// // Print `e` itself, no need for description(). @@ -370,7 +356,7 @@ pub trait Error: Debug + Display { } #[unstable(feature = "error_generic_member_access", issue = "99301")] -impl Provider for dyn Error + 'static { +impl<'b> Provider for dyn Error + 'b { fn provide<'a>(&'a self, req: &mut Demand<'a>) { self.provide(req) } @@ -757,8 +743,8 @@ impl<'a, T: Error + ?Sized> Error for &'a T { Error::source(&**self) } - fn backtrace(&self) -> Option<&Backtrace> { - Error::backtrace(&**self) + fn provide<'b>(&'b self, req: &mut Demand<'b>) { + Error::provide(&**self, req); } } @@ -778,8 +764,8 @@ impl Error for Arc { Error::source(&**self) } - fn backtrace(&self) -> Option<&Backtrace> { - Error::backtrace(&**self) + fn provide<'a>(&'a self, req: &mut Demand<'a>) { + Error::provide(&**self, req); } } @@ -871,6 +857,20 @@ impl Error for alloc::ffi::IntoStringError { } } +impl<'a> dyn Error + 'a { + /// Request a reference of type `T` as context about this error. + #[unstable(feature = "error_generic_member_access", issue = "99301")] + pub fn request_ref(&'a self) -> Option<&'a T> { + core::any::request_ref(self) + } + + /// Request a value of type `T` as context about this error. + #[unstable(feature = "error_generic_member_access", issue = "99301")] + pub fn request_value(&'a self) -> Option { + core::any::request_value(self) + } +} + // Copied from `any.rs`. impl dyn Error + 'static { /// Returns `true` if the inner type is the same as `T`. @@ -910,18 +910,6 @@ impl dyn Error + 'static { None } } - - /// Request a reference of type `T` as context about this error. - #[unstable(feature = "error_generic_member_access", issue = "99301")] - pub fn request_ref(&self) -> Option<&T> { - core::any::request_ref(self) - } - - /// Request a value of type `T` as context about this error. - #[unstable(feature = "error_generic_member_access", issue = "99301")] - pub fn request_value(&self) -> Option { - core::any::request_value(self) - } } impl dyn Error + 'static + Send { @@ -949,13 +937,13 @@ impl dyn Error + 'static + Send { /// Request a reference of type `T` as context about this error. #[unstable(feature = "error_generic_member_access", issue = "99301")] pub fn request_ref(&self) -> Option<&T> { - ::request_ref(self) + ::request_ref(self) } /// Request a value of type `T` as context about this error. #[unstable(feature = "error_generic_member_access", issue = "99301")] pub fn request_value(&self) -> Option { - ::request_value(self) + ::request_value(self) } } @@ -984,13 +972,13 @@ impl dyn Error + 'static + Send + Sync { /// Request a reference of type `T` as context about this error. #[unstable(feature = "error_generic_member_access", issue = "99301")] pub fn request_ref(&self) -> Option<&T> { - ::request_ref(self) + ::request_ref(self) } /// Request a value of type `T` as context about this error. #[unstable(feature = "error_generic_member_access", issue = "99301")] pub fn request_value(&self) -> Option { - ::request_value(self) + ::request_value(self) } } @@ -1467,8 +1455,11 @@ impl Report { /// ```rust /// #![feature(error_reporter)] /// #![feature(backtrace)] + /// #![feature(provide_any)] + /// #![feature(error_generic_member_access)] /// # use std::error::Error; /// # use std::fmt; + /// use std::any::Demand; /// use std::error::Report; /// use std::backtrace::Backtrace; /// @@ -1498,8 +1489,9 @@ impl Report { /// } /// /// impl Error for SuperErrorSideKick { - /// fn backtrace(&self) -> Option<&Backtrace> { - /// Some(&self.backtrace) + /// fn provide<'a>(&'a self, req: &mut Demand<'a>) { + /// req + /// .provide_ref::(&self.backtrace); /// } /// } /// @@ -1552,11 +1544,11 @@ where fn backtrace(&self) -> Option<&Backtrace> { // have to grab the backtrace on the first error directly since that error may not be // 'static - let backtrace = self.error.backtrace(); + let backtrace = (&self.error as &dyn Error).request_ref(); let backtrace = backtrace.or_else(|| { self.error .source() - .map(|source| source.chain().find_map(|source| source.backtrace())) + .map(|source| source.chain().find_map(|source| source.request_ref())) .flatten() }); backtrace @@ -1618,11 +1610,11 @@ impl Report> { fn backtrace(&self) -> Option<&Backtrace> { // have to grab the backtrace on the first error directly since that error may not be // 'static - let backtrace = self.error.backtrace(); + let backtrace = self.error.request_ref(); let backtrace = backtrace.or_else(|| { self.error .source() - .map(|source| source.chain().find_map(|source| source.backtrace())) + .map(|source| source.chain().find_map(|source| source.request_ref())) .flatten() }); backtrace diff --git a/library/std/src/error/tests.rs b/library/std/src/error/tests.rs index a2a35d96ec918..ee999bd65c3c9 100644 --- a/library/std/src/error/tests.rs +++ b/library/std/src/error/tests.rs @@ -1,5 +1,6 @@ use super::Error; use crate::fmt; +use core::any::Demand; #[derive(Debug, PartialEq)] struct A; @@ -198,8 +199,8 @@ where self.source.as_deref() } - fn backtrace(&self) -> Option<&Backtrace> { - self.backtrace.as_ref() + fn provide<'a>(&'a self, req: &mut Demand<'a>) { + self.backtrace.as_ref().map(|bt| req.provide_ref::(bt)); } }