code_ownership 2.1.4 → 2.2.0

data/ext/cargo-vendor/error-stack-0.8.0/examples/exit_code.rs

@@ -0,0 +1,25 @@
+//! Example of using `attach` to set a custom exit code. Requires nightly and std feature.
+
+use core::error::Error;
+use std::process::{ExitCode, Termination as _};
+
+use error_stack::Report;
+
+#[derive(Debug)]
+struct CustomError;
+
+impl Error for CustomError {}
+
+impl core::fmt::Display for CustomError {
+    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        fmt.write_str("Custom Error")
+    }
+}
+
+fn main() -> ExitCode {
+    let report = Report::new(CustomError)
+        .attach_opaque(ExitCode::from(100))
+        .attach("this error has an exit code of 100!");
+
+    report.report()
+}

data/ext/cargo-vendor/{error-stack-0.5.0 → error-stack-0.8.0}/examples/parse_config.rs

@@ -2,10 +2,10 @@
 // This is the same example also used in `lib.rs`. When updating this, don't forget updating the doc
 // example as well. This example is mainly used to generate the output shown in the documentation.
 
-use core::fmt;
+use core::{error::Error, fmt};
 use std::{fs, path::Path};
 
-use error_stack::{Context, Report, ResultExt};
+use error_stack::{Report, ResultExt as _};
 
 pub type Config = String;
 
@@ -25,7 +25,7 @@ impl fmt::Display for ParseConfigError {
     }
 }
 
-impl Context for ParseConfigError {}
+impl Error for ParseConfigError {}
 
 struct Suggestion(&'static str);
 
@@ -34,8 +34,8 @@ fn parse_config(path: impl AsRef<Path>) -> Result<Config, Report<ParseConfigErro
 
     let content = fs::read_to_string(path)
         .change_context(ParseConfigError::new())
-        .attach(Suggestion("use a file you can read next time!"))
-        .attach_printable_lazy(|| format!("could not read file {path:?}"))?;
+        .attach_opaque(Suggestion("use a file you can read next time!"))
+        .attach_with(|| format!("could not read file {}", path.display()))?;
 
     Ok(content)
 }

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

@@ -1,15 +1,15 @@
 use anyhow::Error as AnyhowError;
 
-use crate::{Frame, IntoReportCompat, Report, Result};
+use crate::{Frame, IntoReportCompat, Report};
 
-impl<T> IntoReportCompat for core::result::Result<T, AnyhowError> {
+impl<T> IntoReportCompat for Result<T, AnyhowError> {
     type Err = AnyhowError;
     type Ok = T;
 
     #[track_caller]
-    fn into_report(self) -> Result<T, AnyhowError> {
+    fn into_report(self) -> Result<T, Report<AnyhowError>> {
         match self {
-            Ok(t) => Ok(t),
+            Ok(value) => Ok(value),
             Err(anyhow) => {
                 #[cfg(feature = "std")]
                 let sources = anyhow
@@ -18,13 +18,13 @@ impl<T> IntoReportCompat for core::result::Result<T, AnyhowError> {
                     .map(ToString::to_string)
                     .collect::<alloc::vec::Vec<_>>();
 
-                #[cfg_attr(not(feature = "std"), allow(unused_mut))]
-                let mut report =
+                #[cfg_attr(not(feature = "std"), expect(unused_mut))]
+                let mut report: Report<AnyhowError> =
                     Report::from_frame(Frame::from_anyhow(anyhow, alloc::boxed::Box::new([])));
 
                 #[cfg(feature = "std")]
                 for source in sources {
-                    report = report.attach_printable(source);
+                    report = report.attach(source);
                 }
 
                 Err(report)

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

@@ -1,15 +1,15 @@
 use eyre::Report as EyreReport;
 
-use crate::{Frame, IntoReportCompat, Report, Result};
+use crate::{Frame, IntoReportCompat, Report};
 
-impl<T> IntoReportCompat for core::result::Result<T, EyreReport> {
+impl<T> IntoReportCompat for Result<T, EyreReport> {
     type Err = EyreReport;
     type Ok = T;
 
     #[track_caller]
-    fn into_report(self) -> Result<T, EyreReport> {
+    fn into_report(self) -> Result<T, Report<EyreReport>> {
         match self {
-            Ok(t) => Ok(t),
+            Ok(value) => Ok(value),
             Err(eyre) => {
                 let sources = eyre
                     .chain()
@@ -18,10 +18,11 @@ impl<T> IntoReportCompat for core::result::Result<T, EyreReport> {
                     .collect::<alloc::vec::Vec<_>>();
 
                 #[cfg_attr(not(feature = "std"), allow(unused_mut))]
-                let mut report = Report::from_frame(Frame::from_eyre(eyre, Box::new([])));
+                let mut report: Report<EyreReport> =
+                    Report::from_frame(Frame::from_eyre(eyre, Box::new([])));
 
                 for source in sources {
-                    report = report.attach_printable(source);
+                    report = report.attach(source);
                 }
 
                 Err(report)

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

@@ -11,17 +11,15 @@ mod eyre;
 
 /// Compatibility trait to convert from external libraries to [`Report`].
 ///
-/// **Note**: It's not possible to implement [`Context`] on other error libraries' types from within
-/// `error-stack` as the trait has a blanket implementation relying on [`Error`]. Thus, implementing
-/// the trait would violate the orphan rule; the upstream crate could implement [`Error`] and this
-/// would imply an implementation for [`Context`]. This also implies, that it's not possible to
-/// implement [`ResultExt`] from within `error-stack`.
+/// **Note**: Most error libraries don't implement [`Error`], so it's not possible to directly
+/// convert them to [`Report`]. However, `error-stack` supports converting errors generated from the
+/// [`anyhow`] or [`eyre`] crate via [`IntoReportCompat`].
 ///
-/// [`ResultExt`]: crate::ResultExt
-/// [`Context`]: crate::Context
+/// [`eyre`]: ::eyre
+/// [`anyhow`]: ::anyhow
 /// [`Error`]: core::error::Error
 pub trait IntoReportCompat: Sized {
-    /// Type of the [`Ok`] value in the [`Result`]
+    /// Type of the [`Ok`] value in the [`Result`].
     type Ok;
 
     /// Type of the resulting [`Err`] variant wrapped inside a [`Report<E>`].
@@ -29,7 +27,7 @@ pub trait IntoReportCompat: Sized {
     /// [`Report<E>`]: crate::Report
     type Err;
 
-    /// Converts the [`Err`] variant of the [`Result`] to a [`Report`]
+    /// Converts the [`Err`] variant of the [`Result`] to a [`Report`].
     ///
     /// [`Report`]: crate::Report
     fn into_report(self) -> Result<Self::Ok, Report<Self::Err>>;

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

@@ -0,0 +1,52 @@
+use alloc::string::{String, ToString as _};
+use core::{error::Error, fmt};
+
+use crate::Report;
+
+/// Captures an error message as the context of a [`Report`].
+pub(crate) struct SourceContext(String);
+
+impl SourceContext {
+    pub(crate) fn from_error(value: &dyn Error) -> Self {
+        Self(value.to_string())
+    }
+}
+
+impl fmt::Debug for SourceContext {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&self.0, fmt)
+    }
+}
+
+impl fmt::Display for SourceContext {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, fmt)
+    }
+}
+
+impl Error for SourceContext {}
+
+impl<C> From<C> for Report<C>
+where
+    C: Error + Send + Sync + 'static,
+{
+    #[track_caller]
+    #[inline]
+    fn from(context: C) -> Self {
+        Self::new(context)
+    }
+}
+
+/// A trait for types that can be attached to a [`Report`] without being displayed.
+pub trait OpaqueAttachment: Send + Sync + 'static {}
+
+impl<T: Send + Sync + 'static> OpaqueAttachment for T {}
+
+/// A trait for types that can be attached to a [`Report`] and displayed.
+#[diagnostic::on_unimplemented(
+    message = "to attach this type to a `Report` it must implement `fmt::Display` and `fmt::Debug`",
+    note = "if you want to attach a type that is not printable, use `attach_opaque` instead"
+)]
+pub trait Attachment: OpaqueAttachment + fmt::Display + fmt::Debug {}
+
+impl<T: OpaqueAttachment + fmt::Display + fmt::Debug> Attachment for T {}

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

@@ -1,12 +1,6 @@
-#![cfg(any(feature = "std", rust_1_81))]
-
-#[cfg(rust_1_81)]
-use core::error::Error;
 #[cfg(nightly)]
 use core::error::Request;
-use core::fmt;
-#[cfg(all(feature = "std", not(rust_1_81)))]
-use std::error::Error;
+use core::{error::Error, fmt, ptr};
 
 use crate::Report;
 
@@ -20,7 +14,7 @@ impl<C> ReportError<C> {
 
     pub(crate) const fn from_ref(report: &Report<C>) -> &Self {
         // SAFETY: `ReportError` is a `repr(transparent)` wrapper around `Report`.
-        unsafe { &*(report as *const Report<C>).cast() }
+        unsafe { &*ptr::from_ref(report).cast() }
     }
 }
 
@@ -36,7 +30,6 @@ impl<C> fmt::Display for ReportError<C> {
     }
 }
 
-#[cfg(any(feature = "std", rust_1_81))]
 impl<C> Error for ReportError<C> {
     #[cfg(nightly)]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {

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

@@ -0,0 +1,286 @@
+use core::error::Error;
+
+use crate::Report;
+
+// inspired by the implementation in `std`, see: https://doc.rust-lang.org/1.81.0/src/core/iter/adapters/mod.rs.html#157
+// except with the removal of the Try trait, as it is unstable.
+struct ReportShunt<'a, I, T, C> {
+    iter: I,
+
+    report: &'a mut Option<Report<[C]>>,
+    context_len: usize,
+    context_bound: usize,
+
+    _marker: core::marker::PhantomData<fn() -> *const T>,
+}
+
+impl<I, T, R, C> Iterator for ReportShunt<'_, I, T, C>
+where
+    I: Iterator<Item = Result<T, R>>,
+    R: Into<Report<[C]>>,
+{
+    type Item = T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.context_len >= self.context_bound {
+                return None;
+            }
+
+            let item = self.iter.next()?;
+            let item = item.map_err(Into::into);
+
+            match (item, self.report.as_mut()) {
+                (Ok(output), None) => return Some(output),
+                (Ok(_), Some(_)) => {
+                    // we're now just consuming the iterator to return all related errors
+                    // so we can just ignore the output
+                }
+                (Err(error), None) => {
+                    *self.report = Some(error);
+                    self.context_len += 1;
+                }
+                (Err(error), Some(report)) => {
+                    report.append(error);
+                    self.context_len += 1;
+                }
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if self.report.is_some() {
+            (0, Some(0))
+        } else {
+            let (_, upper) = self.iter.size_hint();
+
+            (0, upper)
+        }
+    }
+}
+
+fn try_process_reports<I, T, R, C, F, U>(
+    iter: I,
+    bound: Option<usize>,
+    mut collect: F,
+) -> Result<U, Report<[C]>>
+where
+    I: Iterator<Item = Result<T, R>>,
+    R: Into<Report<[C]>>,
+    for<'a> F: FnMut(ReportShunt<'a, I, T, C>) -> U,
+{
+    let mut report = None;
+    let shunt = ReportShunt {
+        iter,
+        report: &mut report,
+        context_len: 0,
+        context_bound: bound.unwrap_or(usize::MAX),
+        _marker: core::marker::PhantomData,
+    };
+
+    let value = collect(shunt);
+    report.map_or_else(|| Ok(value), |report| Err(report))
+}
+
+/// An extension trait for iterators that enables error-aware collection of items.
+///
+/// This trait enhances iterators yielding `Result` items by providing methods to
+/// collect successful items into a container while aggregating encountered errors.
+///
+/// # Performance Considerations
+///
+/// These methods may have performance implications as they potentially iterate
+/// through the entire collection, even after encountering errors.
+///
+/// # Unstable Feature
+///
+/// This trait is currently available only under the `unstable` feature flag and
+/// does not adhere to semver guarantees. Its API may change in future releases.
+///
+/// [`Report`]: crate::Report
+pub trait TryReportIteratorExt<C> {
+    /// The type of the successful items in the iterator.
+    type Ok;
+
+    /// Collects the successful items from the iterator into a container, or returns all errors that
+    /// occured.
+    ///
+    /// This method attempts to collect all successful items from the iterator into the specified
+    /// container type. If an error is encountered during iteration, the method will exhaust the
+    /// iterator and return a `Report` containing all errors encountered.
+    ///
+    /// # Errors
+    ///
+    /// If any error is encountered during iteration, the method will return a `Report` containing
+    /// all errors encountered up to that point.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use error_stack::{Report, TryReportIteratorExt};
+    /// use std::io;
+    ///
+    /// fn fetch_fail() -> Result<u8, Report<io::Error>> {
+    ///    # stringify! {
+    ///    ...
+    ///    # };
+    ///    # Err(Report::from(io::Error::new(io::ErrorKind::Other, "error")))
+    /// }
+    ///
+    /// let results = [Ok(1_u8), fetch_fail(), Ok(2), fetch_fail(), fetch_fail()];
+    /// let collected: Result<Vec<_>, _> = results.into_iter().try_collect_reports();
+    /// let error = collected.expect_err("multiple calls should have failed");
+    ///
+    /// assert_eq!(error.current_contexts().count(), 3);
+    /// ```
+    fn try_collect_reports<A>(self) -> Result<A, Report<[C]>>
+    where
+        A: FromIterator<Self::Ok>;
+
+    /// Collects the successful items from the iterator into a container or returns all errors up to
+    /// the specified bound.
+    ///
+    /// This method is similar to [`try_collect_reports`], but it limits the number of errors
+    /// collected to the specified `bound`. If the number of errors encountered exceeds the bound,
+    /// the method stops collecting errors and returns the collected errors up to that point.
+    ///
+    /// [`try_collect_reports`]: TryReportIteratorExt::try_collect_reports
+    ///
+    /// # Errors
+    ///
+    /// If any error is encountered during iteration, the method will return a `Report` containing
+    /// all errors encountered up to the specified bound.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use error_stack::{Report, TryReportIteratorExt};
+    /// use std::io;
+    ///
+    /// fn fetch_fail() -> Result<u8, Report<io::Error>> {
+    ///    # stringify! {
+    ///    ...
+    ///    # };
+    ///    # Err(Report::from(io::Error::new(io::ErrorKind::Other, "error")))
+    /// }
+    ///
+    /// let results = [Ok(1_u8), fetch_fail(), Ok(2), fetch_fail(), fetch_fail()];
+    /// let collected: Result<Vec<_>, _> = results.into_iter().try_collect_reports_bounded(2);
+    /// let error = collected.expect_err("should have failed");
+    ///
+    /// assert_eq!(error.current_contexts().count(), 2);
+    /// ```
+    fn try_collect_reports_bounded<A>(self, bound: usize) -> Result<A, Report<[C]>>
+    where
+        A: FromIterator<Self::Ok>;
+}
+
+impl<T, C, R, I> TryReportIteratorExt<C> for I
+where
+    I: Iterator<Item = Result<T, R>>,
+    R: Into<Report<[C]>>,
+    C: Error + Send + Sync + 'static,
+{
+    type Ok = T;
+
+    fn try_collect_reports<A>(self) -> Result<A, Report<[C]>>
+    where
+        A: FromIterator<Self::Ok>,
+    {
+        try_process_reports(self, None, |shunt| shunt.collect())
+    }
+
+    fn try_collect_reports_bounded<A>(self, bound: usize) -> Result<A, Report<[C]>>
+    where
+        A: FromIterator<Self::Ok>,
+    {
+        try_process_reports(self, Some(bound), |shunt| shunt.collect())
+    }
+}
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::integer_division_remainder_used)]
+    use alloc::{collections::BTreeSet, vec::Vec};
+    use core::fmt;
+
+    use super::*;
+
+    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    struct CustomError(usize);
+
+    impl fmt::Display for CustomError {
+        fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(fmt, "CustomError({})", self.0)
+        }
+    }
+
+    impl core::error::Error for CustomError {}
+
+    #[test]
+    fn try_collect_multiple_errors() {
+        let iter = (0..5).map(|i| {
+            if i % 2 == 0 {
+                Ok(i)
+            } else {
+                Err(Report::new(CustomError(i)))
+            }
+        });
+
+        let result: Result<Vec<_>, Report<[CustomError]>> = iter.try_collect_reports();
+        let report = result.expect_err("should have failed");
+
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 2);
+        assert!(contexts.contains(&CustomError(1)));
+        assert!(contexts.contains(&CustomError(3)));
+    }
+
+    #[test]
+    fn try_collect_multiple_errors_bounded() {
+        let iter = (0..10).map(|i| {
+            if i % 2 == 0 {
+                Ok(i)
+            } else {
+                Err(Report::new(CustomError(i)))
+            }
+        });
+
+        let result: Result<Vec<_>, Report<[CustomError]>> = iter.try_collect_reports_bounded(3);
+        let report = result.expect_err("should have failed");
+
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 3);
+        assert!(contexts.contains(&CustomError(1)));
+        assert!(contexts.contains(&CustomError(3)));
+        assert!(contexts.contains(&CustomError(5)));
+    }
+
+    #[test]
+    fn try_collect_no_errors() {
+        let iter = (0..5).map(Result::<_, Report<CustomError>>::Ok);
+
+        let result: Result<Vec<_>, Report<[CustomError]>> = iter.try_collect_reports();
+        let values = result.expect("should have succeeded");
+
+        assert_eq!(values, [0, 1, 2, 3, 4]);
+    }
+
+    #[test]
+    fn try_collect_multiple_errors_expanded() {
+        let iter = (0..5).map(|i| {
+            if i % 2 == 0 {
+                Ok(i)
+            } else {
+                Err(Report::new(CustomError(i)).expand())
+            }
+        });
+
+        let result: Result<Vec<_>, Report<[CustomError]>> = iter.try_collect_reports();
+        let report = result.expect_err("should have failed");
+
+        let contexts: BTreeSet<_> = report.current_contexts().collect();
+        assert_eq!(contexts.len(), 2);
+        assert!(contexts.contains(&CustomError(1)));
+        assert!(contexts.contains(&CustomError(3)));
+    }
+}

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

@@ -0,0 +1,19 @@
+//! Extension traits for `Report` and `Result`.
+//!
+//! These traits are currently unstable and require the `unstable` feature flag to be enabled.
+//! They provide additional functionality and convenience methods for error handling and
+//! manipulation.
+//!
+//! # Note
+//!
+//! The traits and methods in this module are subject to change and may be modified or
+//! removed in future versions. Use them with caution in production environments.
+
+pub(crate) mod iter;
+#[cfg(feature = "futures")]
+pub(crate) mod stream;
+pub(crate) mod tuple;
+
+#[cfg(feature = "futures")]
+pub use self::stream::{TryCollectReports, TryReportStreamExt};
+pub use self::{iter::TryReportIteratorExt, tuple::TryReportTupleExt};