code_ownership 2.1.4 → 2.2.1

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.8.0/src/serde.rs

@@ -0,0 +1,169 @@
+//! Implementation of general [`Report`] serialization.
+//!
+//! The value can be of any type, currently only printable attachments and context are supported, in
+//! the near future any values will be supported through the use of hooks.
+//!
+//! The serialized [`Report`] is a list of all current sources with the following output:
+//!
+//! ```json
+//! {
+//!     "context": "context display output",
+//!     "attachments": ["all", "attachments", "leading", "up", "to", "this", "context"],
+//!     "sources": [] // recursive render using `frame.sources()`
+//! }
+//! ```
+
+use alloc::{format, vec, vec::Vec};
+use core::error::Error;
+
+use serde_core::{Serialize, Serializer, ser::SerializeMap as _};
+
+use crate::{AttachmentKind, Frame, FrameKind, Report};
+
+struct SerializeAttachment<'a>(&'a Frame);
+
+impl Serialize for SerializeAttachment<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let Self(frame) = self;
+
+        match frame.kind() {
+            FrameKind::Context(_) => {
+                // TODO: for now `Error` is unsupported, upcoming PR will fix via hooks
+                // `SerializeAttachmentList` ensures that no context is ever serialized
+                unimplemented!()
+            }
+            FrameKind::Attachment(AttachmentKind::Opaque(_)) => {
+                // TODO: for now opaque attachments are unsupported, upcoming PR will fix that
+                // `SerializeAttachmentList` ensures that no such attachment is added
+                unimplemented!()
+            }
+            FrameKind::Attachment(AttachmentKind::Printable(attachment)) => {
+                format!("{attachment}").serialize(serializer)
+            }
+        }
+    }
+}
+
+struct SerializeAttachmentList<'a, 'b>(&'a [&'b Frame]);
+
+impl Serialize for SerializeAttachmentList<'_, '_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_seq(
+            self.0
+                .iter()
+                .copied()
+                .filter(|attachment| {
+                    // for now opaque attachments are ignored
+                    !matches!(
+                        attachment.kind(),
+                        FrameKind::Attachment(AttachmentKind::Opaque(_))
+                    )
+                })
+                .map(SerializeAttachment),
+        )
+    }
+}
+
+struct SerializeContext<'a> {
+    attachments: Vec<&'a Frame>,
+    context: &'a (dyn Error + Send + Sync + 'static),
+    sources: &'a [Frame],
+}
+
+impl Serialize for SerializeContext<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let Self {
+            context,
+            attachments,
+            sources,
+        } = self;
+
+        let mut map = serializer.serialize_map(Some(3))?;
+        map.serialize_entry("context", &format!("{context}").as_str())?;
+        map.serialize_entry("attachments", &SerializeAttachmentList(attachments))?;
+        map.serialize_entry("sources", &SerializeSources(sources))?;
+
+        map.end()
+    }
+}
+
+struct SerializeSources<'a>(&'a [Frame]);
+
+impl Serialize for SerializeSources<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_seq(self.0.iter().flat_map(|source| find_next(&[], source)))
+    }
+}
+
+// find the next applicable context and return the serializer
+fn find_next<'a>(head: &[&'a Frame], mut current: &'a Frame) -> Vec<SerializeContext<'a>> {
+    let mut attachments = vec![];
+    attachments.extend(head);
+
+    loop {
+        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: 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_unchecked()).serialize(serializer)
+    }
+}