code_ownership 2.1.4 → 2.2.0

data/ext/cargo-vendor/error-stack-0.8.0/src/result.rs

@@ -0,0 +1,137 @@
+use core::error::Error;
+
+use crate::{Attachment, IntoReport, OpaqueAttachment, Report};
+
+/// Extension trait for [`Result`] to provide context information on
+/// [`Report`]s.
+pub trait ResultExt {
+    /// The context type of the [`Result`] which becomes the `C` in `Report<C>`.
+    type Context: ?Sized;
+
+    /// Type of the [`Ok`] value in the [`Result`].
+    type Ok;
+
+    /// Adds a new printable attachment to the [`Report`] inside the [`Result`].
+    ///
+    /// Applies [`Report::attach`] on the [`Err`] variant, refer to it for more
+    /// information.
+    fn attach<A>(self, attachment: A) -> Result<Self::Ok, Report<Self::Context>>
+    where
+        A: Attachment;
+
+    /// Lazily adds a new printable attachment to the [`Report`] inside the [`Result`].
+    ///
+    /// Applies [`Report::attach`] on the [`Err`] variant, refer to it for more
+    /// information.
+    fn attach_with<A, F>(self, attachment: F) -> Result<Self::Ok, Report<Self::Context>>
+    where
+        A: Attachment,
+        F: FnOnce() -> A;
+
+    /// Adds a new attachment to the [`Report`] inside the [`Result`].
+    ///
+    /// Applies [`Report::attach_opaque`] on the [`Err`] variant, refer to it for more information.
+    fn attach_opaque<A>(self, attachment: A) -> Result<Self::Ok, Report<Self::Context>>
+    where
+        A: OpaqueAttachment;
+
+    /// Lazily adds a new attachment to the [`Report`] inside the [`Result`].
+    ///
+    /// Applies [`Report::attach_opaque`] on the [`Err`] variant, refer to it for more information.
+    fn attach_opaque_with<A, F>(self, attachment: F) -> Result<Self::Ok, Report<Self::Context>>
+    where
+        A: OpaqueAttachment,
+        F: FnOnce() -> A;
+
+    /// Changes the context of the [`Report`] inside the [`Result`].
+    ///
+    /// Applies [`Report::change_context`] on the [`Err`] variant, refer to it for more information.
+    fn change_context<C>(self, context: C) -> Result<Self::Ok, Report<C>>
+    where
+        C: Error + Send + Sync + 'static;
+
+    /// Lazily changes the context of the [`Report`] inside the [`Result`].
+    ///
+    /// Applies [`Report::change_context`] on the [`Err`] variant, refer to it for more information.
+    fn change_context_lazy<C, F>(self, context: F) -> Result<Self::Ok, Report<C>>
+    where
+        C: Error + Send + Sync + 'static,
+        F: FnOnce() -> C;
+}
+
+impl<T, E> ResultExt for Result<T, E>
+where
+    E: IntoReport,
+{
+    type Context = E::Context;
+    type Ok = T;
+
+    #[track_caller]
+    fn attach<A>(self, attachment: A) -> Result<T, Report<E::Context>>
+    where
+        A: Attachment,
+    {
+        match self {
+            Ok(value) => Ok(value),
+            Err(error) => Err(error.into_report().attach(attachment)),
+        }
+    }
+
+    #[track_caller]
+    fn attach_with<A, F>(self, attachment: F) -> Result<T, Report<E::Context>>
+    where
+        A: Attachment,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Ok(value) => Ok(value),
+            Err(error) => Err(error.into_report().attach(attachment())),
+        }
+    }
+
+    #[track_caller]
+    fn attach_opaque<A>(self, attachment: A) -> Result<T, Report<E::Context>>
+    where
+        A: OpaqueAttachment,
+    {
+        match self {
+            Ok(value) => Ok(value),
+            Err(error) => Err(error.into_report().attach_opaque(attachment)),
+        }
+    }
+
+    #[track_caller]
+    fn attach_opaque_with<A, F>(self, attachment: F) -> Result<T, Report<E::Context>>
+    where
+        A: OpaqueAttachment,
+        F: FnOnce() -> A,
+    {
+        match self {
+            Ok(value) => Ok(value),
+            Err(error) => Err(error.into_report().attach_opaque(attachment())),
+        }
+    }
+
+    #[track_caller]
+    fn change_context<C>(self, context: C) -> Result<T, Report<C>>
+    where
+        C: Error + Send + Sync + 'static,
+    {
+        match self {
+            Ok(value) => Ok(value),
+            Err(error) => Err(error.into_report().change_context(context)),
+        }
+    }
+
+    #[track_caller]
+    fn change_context_lazy<C, F>(self, context: F) -> Result<T, Report<C>>
+    where
+        C: Error + Send + Sync + 'static,
+        F: FnOnce() -> C,
+    {
+        match self {
+            Ok(value) => Ok(value),
+            Err(error) => Err(error.into_report().change_context(context())),
+        }
+    }
+}

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

@@ -13,26 +13,25 @@
 //! }
 //! ```
 
-#[cfg_attr(feature = "std", allow(unused_imports))]
 use alloc::{format, vec, vec::Vec};
+use core::error::Error;
 
-use serde::{ser::SerializeMap, Serialize, Serializer};
+use serde_core::{Serialize, Serializer, ser::SerializeMap as _};
 
-use crate::{AttachmentKind, Context, Frame, FrameKind, Report};
+use crate::{AttachmentKind, Frame, FrameKind, Report};
 
 struct SerializeAttachment<'a>(&'a Frame);
 
-impl<'a> Serialize for SerializeAttachment<'a> {
+impl Serialize for SerializeAttachment<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         let Self(frame) = self;
 
-        #[allow(clippy::match_same_arms)]
         match frame.kind() {
             FrameKind::Context(_) => {
-                // TODO: for now `Context` is unsupported, upcoming PR will fix via hooks
+                // TODO: for now `Error` is unsupported, upcoming PR will fix via hooks
                 // `SerializeAttachmentList` ensures that no context is ever serialized
                 unimplemented!()
             }
@@ -50,7 +49,7 @@ impl<'a> Serialize for SerializeAttachment<'a> {
 
 struct SerializeAttachmentList<'a, 'b>(&'a [&'b Frame]);
 
-impl<'a, 'b> Serialize for SerializeAttachmentList<'a, 'b> {
+impl Serialize for SerializeAttachmentList<'_, '_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -73,11 +72,11 @@ impl<'a, 'b> Serialize for SerializeAttachmentList<'a, 'b> {
 
 struct SerializeContext<'a> {
     attachments: Vec<&'a Frame>,
-    context: &'a dyn Context,
+    context: &'a (dyn Error + Send + Sync + 'static),
     sources: &'a [Frame],
 }
 
-impl<'a> Serialize for SerializeContext<'a> {
+impl Serialize for SerializeContext<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -99,7 +98,7 @@ impl<'a> Serialize for SerializeContext<'a> {
 
 struct SerializeSources<'a>(&'a [Frame]);
 
-impl<'a> Serialize for SerializeSources<'a> {
+impl Serialize for SerializeSources<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -114,41 +113,57 @@ fn find_next<'a>(head: &[&'a Frame], mut current: &'a Frame) -> Vec<SerializeCon
     attachments.extend(head);
 
     loop {
-        if let FrameKind::Context(context) = current.kind() {
-            // found the context, return all attachments (reversed)
-            attachments.reverse();
-
-            return vec![SerializeContext {
-                attachments,
-                context,
-                sources: current.sources(),
-            }];
-        } else if current.sources().len() > 1 {
-            // current is an attachment, add to attachments and recursively probe
-            attachments.push(current);
-
-            return current
-                .sources()
-                .iter()
-                .flat_map(|source| find_next(&attachments, source))
-                .collect();
-        } else if current.sources().len() == 1 {
-            attachments.push(current);
-
-            current = &current.sources()[0];
-        } else {
-            // there are no more frames, therefore we need to abandon
-            // this is theoretically impossible (the bottom is always a context), but not enforced
-            return vec![];
+        match current.kind() {
+            FrameKind::Context(context) => {
+                // found the context, return all attachments (reversed)
+                attachments.reverse();
+
+                return vec![SerializeContext {
+                    attachments,
+                    context,
+                    sources: current.sources(),
+                }];
+            }
+            FrameKind::Attachment(_) => match current.sources() {
+                [] => {
+                    // there are no more frames, therefore we need to abandon
+                    // this is theoretically impossible (the bottom is always a context), but not
+                    // enforced
+                    return vec![];
+                }
+                [source] => {
+                    attachments.push(current);
+
+                    current = source;
+                }
+                sources => {
+                    // there are multiple sources, we need to recursively probe each of them
+                    attachments.push(current);
+
+                    return sources
+                        .iter()
+                        .flat_map(|source| find_next(&attachments, source))
+                        .collect();
+                }
+            },
         }
     }
 }
 
-impl<C: Context> Serialize for Report<C> {
+impl<C: Error + Send + Sync + 'static> Serialize for Report<C> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        SerializeSources(self.current_frames_unchecked()).serialize(serializer)
+    }
+}
+
+impl<C: Error + Send + Sync + 'static> Serialize for Report<[C]> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        SerializeSources(self.current_frames()).serialize(serializer)
+        SerializeSources(self.current_frames_unchecked()).serialize(serializer)
     }
 }