code_ownership 2.1.4 → 2.2.0

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/fmt/config.rs

@@ -9,7 +9,7 @@ pub(crate) struct Config {
 
 #[cfg(any(feature = "std", feature = "hooks"))]
 impl Config {
-    pub(crate) fn new(color_mode: ColorMode, charset: Charset, alternate: bool) -> Self {
+    pub(crate) const fn new(color_mode: ColorMode, charset: Charset, alternate: bool) -> Self {
         let context = HookContext::new(Format::new(alternate, color_mode, charset));
 
         Self { context }

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/fmt/hook.rs

@@ -3,13 +3,12 @@
 // implementation: `pub(crate)` and `pub`.
 #![cfg_attr(not(feature = "std"), allow(unreachable_pub))]
 
-#[cfg_attr(feature = "std", allow(unused_imports))]
 use alloc::{boxed::Box, string::String, vec::Vec};
 use core::{any::TypeId, mem};
 
 pub(crate) use default::install_builtin_hooks;
 
-use crate::fmt::{charset::Charset, ColorMode, Frame};
+use crate::fmt::{ColorMode, Frame, charset::Charset};
 
 pub(crate) struct Format {
     alternate: bool,
@@ -112,14 +111,14 @@ crate::hook::context::impl_hook_context! {
     /// Report::install_debug_hook::<Secret>(|_, _| {});
     ///
     /// let report = Report::new(Error::from(ErrorKind::InvalidInput))
-    ///     .attach(HttpResponseStatusCode(404))
-    ///     .attach(Suggestion("do you have a connection to the internet?"))
-    ///     .attach(HttpResponseStatusCode(405))
-    ///     .attach(Warning("unable to determine environment"))
-    ///     .attach(Secret("pssst, don't tell anyone else c;"))
-    ///     .attach(Suggestion("execute the program from the fish shell"))
-    ///     .attach(HttpResponseStatusCode(501))
-    ///     .attach(Suggestion("try better next time!"));
+    ///     .attach_opaque(HttpResponseStatusCode(404))
+    ///     .attach_opaque(Suggestion("do you have a connection to the internet?"))
+    ///     .attach_opaque(HttpResponseStatusCode(405))
+    ///     .attach_opaque(Warning("unable to determine environment"))
+    ///     .attach_opaque(Secret("pssst, don't tell anyone else c;"))
+    ///     .attach_opaque(Suggestion("execute the program from the fish shell"))
+    ///     .attach_opaque(HttpResponseStatusCode(501))
+    ///     .attach_opaque(Suggestion("try better next time!"));
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -198,8 +197,8 @@ crate::hook::context::impl_hook_context! {
     /// });
     ///
     /// let report = Report::new(std::io::Error::from(ErrorKind::InvalidInput))
-    ///     .attach(Computation(2))
-    ///     .attach(Computation(3));
+    ///     .attach_opaque(Computation(2))
+    ///     .attach_opaque(Computation(3));
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -240,7 +239,7 @@ impl<T> HookContext<T> {
         self.inner().extra().color
     }
 
-    /// The requested [`Charset`] for this invocation of hooks
+    /// The requested [`Charset`] for this invocation of hooks.
     ///
     /// Hooks can be invoked in using different charsets, which reflect the capabilities of the
     /// terminal.
@@ -278,11 +277,11 @@ impl<T> HookContext<T> {
     /// });
     ///
     /// let report = Report::new(std::io::Error::from(ErrorKind::InvalidInput))
-    ///     .attach(Error {
+    ///     .attach_opaque(Error {
     ///         code: 404,
     ///         reason: "not found - server cannot find requested resource",
     ///     })
-    ///     .attach(Error {
+    ///     .attach_opaque(Error {
     ///         code: 405,
     ///         reason: "bad request - server cannot or will not process request",
     ///     });
@@ -305,7 +304,7 @@ impl<T> HookContext<T> {
     /// ```
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__hookcontext_emit.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__hookcontext_emit.snap")))]
     /// </pre>
     pub fn push_appendix(&mut self, content: impl Into<String>) {
         self.inner_mut().extra_mut().appendix.push(content.into());
@@ -332,7 +331,7 @@ impl<T> HookContext<T> {
     /// });
     ///
     /// let report = Report::new(io::Error::from(io::ErrorKind::InvalidInput))
-    ///     .attach(Suggestion("try better next time"));
+    ///     .attach_opaque(Suggestion("try better next time"));
     ///
     /// # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
     /// # fn render(value: String) -> String {
@@ -352,7 +351,7 @@ impl<T> HookContext<T> {
     /// ```
     ///
     /// <pre>
-    #[doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__diagnostics_add.snap"))]
+    #[cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__diagnostics_add.snap")))]
     /// </pre>
     pub fn push_body(&mut self, content: impl Into<String>) {
         self.inner_mut().extra_mut().body.push(content.into());
@@ -410,8 +409,8 @@ fn into_boxed_hook<T: Send + Sync + 'static>(
 /// Hooks are added via [`.insert()`], which will wrap the function in an additional closure.
 /// This closure will downcast/request the [`Frame`] to the requested type.
 ///
-/// If not set, opaque attachments (added via [`.attach()`]) won't be rendered in the [`Debug`]
-/// output.
+/// If not set, opaque attachments (added via [`.attach_opaque()`]) won't be rendered in the
+/// [`Debug`] output.
 ///
 /// The default implementation provides supports for [`Backtrace`] and [`SpanTrace`],
 /// if their necessary features have been enabled.
@@ -421,7 +420,8 @@ fn into_boxed_hook<T: Send + Sync + 'static>(
 /// [`Display`]: core::fmt::Display
 /// [`Debug`]: core::fmt::Debug
 /// [`.insert()`]: Hooks::insert
-#[allow(clippy::field_scoped_visibility_modifiers)]
+/// [`.attach_opaque()`]: crate::Report::attach_opaque
+#[expect(clippy::field_scoped_visibility_modifiers)]
 pub(crate) struct Hooks {
     // We use `Vec`, instead of `HashMap` or `BTreeMap`, so that ordering is consistent with the
     // insertion order of types.
@@ -455,8 +455,7 @@ impl Hooks {
 mod default {
     #[cfg(any(feature = "backtrace", feature = "spantrace"))]
     use alloc::format;
-    #[cfg_attr(feature = "std", allow(unused_imports))]
-    use alloc::string::ToString;
+    use alloc::string::ToString as _;
     use core::{
         panic::Location,
         sync::atomic::{AtomicBool, Ordering},
@@ -472,8 +471,8 @@ mod default {
     use tracing_error::SpanTrace;
 
     use crate::{
-        fmt::{hook::HookContext, location::LocationAttachment},
         Report,
+        fmt::{hook::HookContext, location::LocationAttachment},
     };
 
     pub(crate) fn install_builtin_hooks() {

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/fmt/location.rs

@@ -15,7 +15,7 @@ impl<'a, 'loc> LocationAttachment<'a, 'loc> {
 }
 
 impl fmt::Display for LocationAttachment<'_, '_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let location = self.location;
 
         let mut style = Style::new();
@@ -24,9 +24,9 @@ impl fmt::Display for LocationAttachment<'_, '_> {
             ColorMode::None => {}
             ColorMode::Color => style.set_foreground(Color::Black, true),
             ColorMode::Emphasis => style.set_display(DisplayStyle::new().with_italic(true)),
-        };
+        }
 
-        f.write_fmt(format_args!("at {}", style.apply(&location)))?;
+        fmt.write_fmt(format_args!("at {}", style.apply(&location)))?;
 
         Ok(())
     }

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/fmt/mod.rs

@@ -8,18 +8,18 @@
 //! The [`Debug`] implementation can be easily extended using hooks. Hooks are functions of the
 //! signature `Fn(&T, &mut HookContext<T>)`, they provide an ergonomic way to partially modify the
 //! output format and enable custom output for types that are not necessarily added via
-//! [`Report::attach_printable`] or are unable to implement [`Display`].
+//! [`Report::attach`] or are unable to implement [`Display`].
 //!
 //! Hooks can be attached through the central hooking mechanism which `error-stack`
 //! provides via [`Report::install_debug_hook`].
 //!
-//! Hooks are called for contexts which provide additional values through [`Context::provide`] and
-//! attachments which are added via [`Report::attach`] or [`Report::attach_printable`]. The order of
+//! Hooks are called for contexts which provide additional values through [`Error::provide`] and
+//! attachments which are added via [`Report::attach`] or [`Report::attach_opaque`]. The order of
 //! [`Report::install_debug_hook`] calls determines the order of the rendered output. Note, that
-//! Hooks get called on all values provided by [`Context::provide`], but not on the [`Context`]
-//! object itself. Therefore if you want to call a hook on a [`Context`] to print in addition to its
-//! [`Display`] implementation, you may want to call [`request.provide_ref(self)`] inside of
-//! [`Context::provide`].
+//! Hooks get called on all values provided by [`Error::provide`], but not on the [`Error`]
+//! object itself. Therefore if you want to call a hook on a [`Error`] context to print in addition
+//! to its [`Display`] implementation, you may want to call [`request.provide_ref(self)`] inside of
+//! [`Error::provide`].
 //!
 //! [`request.provide_ref(self)`]: core::error::Request::provide_ref
 //!
@@ -94,10 +94,10 @@
 //!
 //!
 //! let report = Report::new(Error::from(ErrorKind::InvalidInput))
-//!     .attach_printable(ErrorCode(404))
-//!     .attach(Suggestion("try to be connected to the internet."))
-//!     .attach(Suggestion("try better next time!"))
-//!     .attach(Warning("unable to fetch resource"));
+//!     .attach(ErrorCode(404))
+//!     .attach_opaque(Suggestion("try to be connected to the internet."))
+//!     .attach_opaque(Suggestion("try better next time!"))
+//!     .attach_opaque(Warning("unable to fetch resource"));
 //!
 //! # Report::set_color_mode(error_stack::fmt::ColorMode::Emphasis);
 //! # fn render(value: String) -> String {
@@ -124,13 +124,13 @@
 //! The output of `println!("{report:?}")`:
 //!
 //! <pre>
-#![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__doc.snap"))]
+#![cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt__doc.snap")))]
 //! </pre>
 //!
 //! The output of `println!("{report:#?}")`:
 //!
 //! <pre>
-#![doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt_doc_alt.snap"))]
+#![cfg_attr(doc, doc = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/snapshots/doc/fmt_doc_alt.snap")))]
 //! </pre>
 //!
 //! ## Implementation Details
@@ -187,7 +187,7 @@
 //!
 //! While formatting we view the [`Report`]s as a tree of [`Frame`]s, therefore the following
 //! explanation will use terminology associated with trees, every [`Frame`] is a node and can have
-//! `0..n` children, a node that has no children (a leaf) is guaranteed to be a [`Context`].
+//! `0..n` children, a node that has no children (a leaf) is guaranteed to be a [`Error`] context.
 //!
 //! A list is a list of nodes where each node in the list is the parent of the next node in the list
 //! and only has a single child. The last node in the list is exempt of that rule of that rule and
@@ -200,9 +200,10 @@
 //! (`1`), but `1` is not the immediate context parent of `3` and `4` (`2`) is. In the more detailed
 //! example `(Dᶜ, Hᶜ, Iᶜ)` is considered a group because they share the same *immediate* context
 //! parent `Aᶜ`, important to note is that we only refer to immediate context parents, `Fᵃ` is the
-//! immediate parent of `Iᶜ`, but is not a [`Context`], therefore to find the immediate context
-//! parent, we travel up the tree until we encounter our first [`Context`] node. Groups always
-//! contain lists, for the sake of clarity this explanation only shows the first element.
+//! immediate parent of `Iᶜ`, but is not a [`Error`] context, therefore to find the immediate
+//! context parent, we travel up the tree until we encounter our first [`Error`] context node.
+//! Groups always contain lists, for the sake of clarity this explanation only shows the first
+//! element.
 //!
 //! The rules stated above also implies some additional rules:
 //! * lists are never empty
@@ -213,7 +214,7 @@
 //! Using the aforementioned delimiters for lists and groups the end result would be:
 //!
 //! Overview Tree: `[0, 1] ([2] ([3], [4, 5]), [6, 7, 8])`
-//! Detailed Tree: `[Aᶜ] ([Dᶜ], [Hᶜ], [Iᶜ])`
+//! Detailed Tree: `[Aᶜ] ([Dᶜ], [Hᶜ], [Iᶜ])`.
 //!
 //! Attachments are not ordered by insertion order but by depth in the tree. The depth in the tree
 //! is the inverse of the insertion order, this means that the [`Debug`] output of all
@@ -299,16 +300,16 @@ mod hook;
 mod location;
 mod r#override;
 
-use alloc::collections::VecDeque;
-#[cfg_attr(feature = "std", allow(unused_imports))]
 use alloc::{
     borrow::ToOwned,
+    collections::VecDeque,
     format,
-    string::{String, ToString},
+    string::{String, ToString as _},
     vec,
     vec::Vec,
 };
 use core::{
+    error::Error,
     fmt::{self, Debug, Display, Formatter},
     iter::once,
     mem,
@@ -319,16 +320,16 @@ pub use color::ColorMode;
 #[cfg(any(feature = "std", feature = "hooks"))]
 pub use hook::HookContext;
 #[cfg(any(feature = "std", feature = "hooks"))]
-pub(crate) use hook::{install_builtin_hooks, Format, Hooks};
+pub(crate) use hook::{Format, Hooks, install_builtin_hooks};
 #[cfg(not(any(feature = "std", feature = "hooks")))]
 use location::LocationAttachment;
 
 use crate::{
+    AttachmentKind, Frame, FrameKind, Report,
     fmt::{
         color::{Color, DisplayStyle, Style},
         config::Config,
     },
-    AttachmentKind, Context, Frame, FrameKind, Report,
 };
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -433,9 +434,9 @@ struct SymbolDisplay<'a> {
 }
 
 impl Display for SymbolDisplay<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         for symbol in self.inner {
-            f.write_str(symbol.to_str(self.charset))?;
+            fmt.write_str(symbol.to_str(self.charset))?;
         }
 
         Ok(())
@@ -459,12 +460,12 @@ enum Spacing {
 
 #[derive(Debug, Copy, Clone)]
 struct Indent {
-    /// Is this used in a group context, if that is the case, then add a single leading space
+    /// Is this used in a group context? If that is the case, then add a single leading space.
     group: bool,
-    /// Should the indent be visible, if that isn't the case it will render a space instead of
-    /// `|`
+    /// Should the indent be visible? If that isn't the case it will render a space instead of
+    /// `|`.
     visible: bool,
-    /// Should spacing included, this is the difference between `|   ` and `|`
+    /// Should spacing be included? This is the difference between `|   ` and `|`.
     spacing: Option<Spacing>,
 }
 
@@ -568,7 +569,7 @@ enum Instruction {
     Context {
         position: Position,
     },
-    /// `Position::Final` means *that nothing follows*
+    /// `Position::Final` means *that nothing follows*.
     Attachment {
         position: Position,
     },
@@ -584,10 +585,12 @@ enum PreparedInstruction<'a> {
 }
 
 impl Instruction {
-    // Reason: the match arms are the same intentionally, this makes it more clean which variant
-    //  emits which and also keeps it nicely formatted.
-    #[allow(clippy::match_same_arms)]
-    fn prepare(&self) -> PreparedInstruction {
+    #[expect(
+        clippy::match_same_arms,
+        reason = "the match arms are the same intentionally, this makes it more clean which \
+                  variant emits which and also keeps it nicely formatted."
+    )]
+    fn prepare(&self) -> PreparedInstruction<'_> {
         match self {
             Self::Value { value, style } => PreparedInstruction::Content(value, style),
 
@@ -672,7 +675,7 @@ struct LineDisplay<'a> {
 }
 
 impl Display for LineDisplay<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         for instruction in self.line.0.iter().rev() {
             Display::fmt(
                 &InstructionDisplay {
@@ -680,7 +683,7 @@ impl Display for LineDisplay<'_> {
                     charset: self.charset,
                     instruction,
                 },
-                f,
+                fmt,
             )?;
         }
 
@@ -691,7 +694,7 @@ impl Display for LineDisplay<'_> {
 struct Lines(VecDeque<Line>);
 
 impl Lines {
-    fn new() -> Self {
+    const fn new() -> Self {
         Self(VecDeque::new())
     }
 
@@ -753,7 +756,7 @@ fn collect<'a>(root: &'a Frame, prefix: &'a [&Frame]) -> (Vec<&'a Frame>, &'a [F
     (stack, next)
 }
 
-/// Partition the tree, this looks for the first `Context`,
+/// Partition the tree, this looks for the first context frame,
 /// then moves it up the chain and adds it to our results.
 /// Once we reach the end all remaining items on the stack are added to the prefix pile,
 /// which will be used in next iteration.
@@ -774,7 +777,7 @@ fn partition<'a>(stack: &'a [&'a Frame]) -> (Vec<(&'a Frame, Vec<&'a Frame>)>, V
     (result, queue)
 }
 
-fn debug_context(context: &dyn Context, mode: ColorMode) -> Lines {
+fn debug_context(context: &(dyn Error + Send + Sync + 'static), mode: ColorMode) -> Lines {
     context
         .to_string()
         .lines()
@@ -806,7 +809,7 @@ impl Opaque {
         Self(0)
     }
 
-    fn increase(&mut self) {
+    const fn increase(&mut self) {
         self.0 += 1;
     }
 
@@ -825,7 +828,10 @@ impl Opaque {
     }
 }
 
-#[allow(clippy::needless_pass_by_ref_mut)]
+#[cfg_attr(
+    not(any(feature = "std", feature = "hooks")),
+    expect(clippy::needless_pass_by_ref_mut)
+)]
 fn debug_attachments_invoke<'a>(
     frames: impl IntoIterator<Item = &'a Frame>,
     config: &mut Config,
@@ -840,15 +846,19 @@ fn debug_attachments_invoke<'a>(
         .map(|frame| match frame.kind() {
             #[cfg(any(feature = "std", feature = "hooks"))]
             FrameKind::Context(_) => Some(
-                Report::invoke_debug_format_hook(|hooks| hooks.call(frame, context))
-                    .then(|| context.take_body())
-                    .unwrap_or_default(),
+                if Report::invoke_debug_format_hook(|hooks| hooks.call(frame, context)) {
+                    context.take_body()
+                } else {
+                    Vec::new()
+                },
             ),
             #[cfg(any(feature = "std", feature = "hooks"))]
             FrameKind::Attachment(AttachmentKind::Printable(attachment)) => Some(
-                Report::invoke_debug_format_hook(|hooks| hooks.call(frame, context))
-                    .then(|| context.take_body())
-                    .unwrap_or_else(|| vec![attachment.to_string()]),
+                if Report::invoke_debug_format_hook(|hooks| hooks.call(frame, context)) {
+                    context.take_body()
+                } else {
+                    vec![attachment.to_string()]
+                },
             ),
             #[cfg(any(feature = "std", feature = "hooks"))]
             FrameKind::Attachment(AttachmentKind::Opaque(_)) => {
@@ -1024,7 +1034,7 @@ fn debug_frame(root: &Frame, prefix: &[&Frame], config: &mut Config) -> Vec<Line
             // The attachments are rendered as direct descendants of the parent context
             let head_context = debug_context(
                 match head.kind() {
-                    FrameKind::Context(c) => c,
+                    FrameKind::Context(context) => context,
                     FrameKind::Attachment(_) => unreachable!(),
                 },
                 config.color_mode(),
@@ -1083,16 +1093,16 @@ fn debug_frame(root: &Frame, prefix: &[&Frame], config: &mut Config) -> Vec<Line
     vec![debug_render(head, contexts, sources)]
 }
 
-impl<C> Debug for Report<C> {
+impl<C: ?Sized> Debug for Report<C> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         let mut config = Config::load(fmt.alternate());
 
         let color = config.color_mode();
         let charset = config.charset();
 
-        #[cfg_attr(not(any(feature = "std", feature = "hooks")), allow(unused_mut))]
+        #[cfg_attr(not(any(feature = "std", feature = "hooks")), expect(unused_mut))]
         let mut lines = self
-            .current_frames()
+            .current_frames_unchecked()
             .iter()
             .flat_map(|frame| debug_frame(frame, &[], &mut config))
             .enumerate()
@@ -1152,7 +1162,7 @@ impl<C> Debug for Report<C> {
     }
 }
 
-impl<Context> Display for Report<Context> {
+impl<C: ?Sized> Display for Report<C> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         for (index, frame) in self
             .frames()

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/frame/frame_impl.rs

@@ -1,10 +1,9 @@
-#[cfg_attr(feature = "std", allow(unused_imports))]
 use alloc::boxed::Box;
 #[cfg(nightly)]
-use core::error::{Error, Request};
-use core::{any::Any, fmt};
+use core::error::Request;
+use core::{any::Any, error::Error, fmt};
 
-use crate::{AttachmentKind, Context, Frame, FrameKind};
+use crate::{AttachmentKind, Frame, FrameKind};
 
 /// Internal representation of a [`Frame`].
 pub(super) trait FrameImpl: Send + Sync + 'static {
@@ -19,22 +18,20 @@ pub(super) trait FrameImpl: Send + Sync + 'static {
     fn provide<'a>(&'a self, request: &mut Request<'a>);
 }
 
-#[cfg(nightly)]
 impl fmt::Debug for Box<dyn FrameImpl> {
     fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
         unreachable!()
     }
 }
 
-#[cfg(nightly)]
 impl fmt::Display for Box<dyn FrameImpl> {
     fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
         unreachable!()
     }
 }
 
-#[cfg(nightly)]
 impl Error for Box<dyn FrameImpl> {
+    #[cfg(nightly)]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
         (**self).provide(request);
     }
@@ -44,7 +41,7 @@ struct ContextFrame<C> {
     context: C,
 }
 
-impl<C: Context> FrameImpl for ContextFrame<C> {
+impl<C: Error + Send + Sync + 'static> FrameImpl for ContextFrame<C> {
     fn kind(&self) -> FrameKind<'_> {
         FrameKind::Context(&self.context)
     }
@@ -59,7 +56,7 @@ impl<C: Context> FrameImpl for ContextFrame<C> {
 
     #[cfg(nightly)]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        Context::provide(&self.context, request);
+        Error::provide(&self.context, request);
     }
 }
 
@@ -129,7 +126,7 @@ impl fmt::Display for AnyhowContext {
 }
 
 #[cfg(feature = "anyhow")]
-impl Context for AnyhowContext {
+impl Error for AnyhowContext {
     #[cfg(all(nightly, feature = "std"))]
     #[inline]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
@@ -154,7 +151,7 @@ impl FrameImpl for AnyhowContext {
     #[cfg(nightly)]
     #[inline]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        Context::provide(self, request);
+        Error::provide(self, request);
     }
 }
 
@@ -176,7 +173,7 @@ impl fmt::Display for EyreContext {
 }
 
 #[cfg(feature = "eyre")]
-impl Context for EyreContext {
+impl Error for EyreContext {
     #[cfg(nightly)]
     #[inline]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
@@ -201,15 +198,15 @@ impl FrameImpl for EyreContext {
     #[cfg(nightly)]
     #[inline]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        Context::provide(self, request);
+        Error::provide(self, request);
     }
 }
 
 impl Frame {
-    /// Creates a frame from a [`Context`].
+    /// Creates a frame from an [`Error`].
     pub(crate) fn from_context<C>(context: C, sources: Box<[Self]>) -> Self
     where
-        C: Context,
+        C: Error + Send + Sync + 'static,
     {
         Self {
             frame: Box::new(ContextFrame { context }),

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/frame/kind.rs

@@ -1,6 +1,7 @@
-use core::fmt::{Debug, Display};
-
-use crate::Context;
+use core::{
+    error::Error,
+    fmt::{Debug, Display},
+};
 
 /// Classification of the contents of a [`Frame`], determined by how it was created.
 ///
@@ -10,24 +11,24 @@ pub enum FrameKind<'f> {
     ///
     /// [`Report::new()`]: crate::Report::new
     /// [`change_context()`]: crate::Report::change_context
-    Context(&'f dyn Context),
-    /// Frame was created through [`attach()`] or [`attach_printable()`].
+    Context(&'f (dyn Error + Send + Sync + 'static)),
+    /// Frame was created through [`attach()`] or [`attach_opaque()`].
     ///
     /// [`attach()`]: crate::Report::attach
-    /// [`attach_printable()`]: crate::Report::attach_printable
+    /// [`attach_opaque()`]: crate::Report::attach_opaque
     Attachment(AttachmentKind<'f>),
 }
 
 /// Classification of an attachment which is determined by the method it was created in.
 #[non_exhaustive]
 pub enum AttachmentKind<'f> {
-    /// A generic attachment created through [`attach()`].
+    /// A generic attachment created through [`attach_opaque()`].
     ///
-    /// [`attach()`]: crate::Report::attach
+    /// [`attach_opaque()`]: crate::Report::attach_opaque
     Opaque(&'f (dyn Send + Sync + 'static)),
-    /// A printable attachment created through [`attach_printable()`].
+    /// A printable attachment created through [`attach()`].
     ///
-    /// [`attach_printable()`]: crate::Report::attach_printable
+    /// [`attach()`]: crate::Report::attach
     Printable(&'f dyn Printable),
 }
 

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/src/frame/mod.rs

@@ -1,29 +1,28 @@
 mod frame_impl;
 mod kind;
 
-#[cfg_attr(feature = "std", allow(unused_imports))]
 use alloc::boxed::Box;
 #[cfg(nightly)]
-use core::error::{self, Error};
-use core::{any::TypeId, fmt};
+use core::error;
+use core::{any::TypeId, error::Error, fmt};
 
 use self::frame_impl::FrameImpl;
 pub use self::kind::{AttachmentKind, FrameKind};
 
 /// A single context or attachment inside of a [`Report`].
 ///
-/// `Frame`s are organized as a singly linked list, which can be iterated by calling
-/// [`Report::frames()`]. The head contains the current context or attachment, and the tail contains
-/// the root context created by [`Report::new()`]. The next `Frame` can be accessed by requesting it
-/// by calling [`Report::request_ref()`].
+/// `Frame`s are organized as a tree, which can be traversed by calling [`Report::frames()`].
+/// The top contains the most recent context or attachment, the leaves contain the root contexts
+/// created by [`Report::new()`]. The `Frame`s below a frame can be accessed by calling
+/// [`sources()`].
 ///
 /// [`Report`]: crate::Report
 /// [`Report::frames()`]: crate::Report::frames
 /// [`Report::new()`]: crate::Report::new
-/// [`Report::request_ref()`]: crate::Report::request_ref
+/// [`sources()`]: Self::sources
 pub struct Frame {
     frame: Box<dyn FrameImpl>,
-    sources: Box<[Frame]>,
+    sources: Box<[Self]>,
 }
 
 impl Frame {
@@ -97,7 +96,6 @@ impl Frame {
         self.frame.as_any().type_id()
     }
 
-    #[cfg(nightly)]
     pub(crate) fn as_error(&self) -> &impl Error {
         &self.frame
     }