code_ownership 2.1.4 → 2.2.0

data/ext/cargo-vendor/error-stack-0.8.0/tests/test_frame.rs

@@ -0,0 +1,136 @@
+#![cfg_attr(nightly, feature(error_generic_member_access))]
+
+mod common;
+
+use core::{any::TypeId, iter::zip, ops::ControlFlow, panic::Location};
+
+use common::*;
+
+#[test]
+fn opaque_attachment() {
+    let mut report = create_report()
+        .attach_opaque(AttachmentA(10))
+        .attach_opaque(AttachmentB(20));
+
+    let flow = report.frames_mut(|frame| {
+        let source = frame
+            .sources_mut()
+            .first_mut()
+            .expect("No source frame found");
+        let attachment = source
+            .downcast_mut::<AttachmentA>()
+            .expect("Wrong source frame");
+        attachment.0 += 10;
+        ControlFlow::Break(())
+    });
+    assert!(flow.is_break(), "No frame found");
+
+    let frame = report.frames().next().expect("No frame found");
+    assert_eq!(frame.sources().len(), 1);
+    let source = frame.sources().first().expect("No source frame found");
+    let attachment = source
+        .downcast_ref::<AttachmentA>()
+        .expect("Wrong source frame");
+    assert_eq!(attachment.0, 20);
+}
+
+#[test]
+fn sources() {
+    let mut report_a = create_report().attach_opaque(AttachmentA(10)).expand();
+    let report_b = create_report().attach_opaque(AttachmentA(20));
+    report_a.push(report_b);
+    let mut report = report_a.attach_opaque(AttachmentB(30));
+
+    let flow = report.frames_mut(|frame| {
+        assert_eq!(frame.sources().len(), 2);
+
+        for source in frame.sources_mut() {
+            let attachment = source
+                .downcast_mut::<AttachmentA>()
+                .expect("Wrong source frame");
+            attachment.0 += 5;
+        }
+        ControlFlow::Break(())
+    });
+    assert!(flow.is_break(), "No frames");
+
+    let frame = report.frames().next().expect("No frames");
+    for (source, expect) in zip(frame.sources(), [15, 25]) {
+        let attachment = source
+            .downcast_ref::<AttachmentA>()
+            .expect("Wrong source frame");
+        assert_eq!(attachment.0, expect);
+    }
+}
+
+#[test]
+fn printable_attachment() {
+    let mut report = create_report()
+        .attach(PrintableA(10))
+        .attach(PrintableB(20));
+
+    let flow = report.frames_mut(|frame| {
+        let source = frame
+            .sources_mut()
+            .first_mut()
+            .expect("No source frame found");
+        let attachment = source
+            .downcast_mut::<PrintableA>()
+            .expect("Wrong source frame");
+        attachment.0 += 10;
+        ControlFlow::Break(())
+    });
+    assert!(flow.is_break(), "No frame found");
+
+    let frame = report.frames().next().expect("No frame found");
+    assert_eq!(frame.sources().len(), 1);
+    let source = frame.sources().first().expect("No source frame found");
+    let attachment = source
+        .downcast_ref::<PrintableA>()
+        .expect("Wrong source frame");
+    assert_eq!(attachment.0, 20);
+}
+
+#[test]
+fn context() {
+    let mut report = create_report().change_context(ContextA(10));
+
+    let flow = report.frames_mut(|frame| {
+        assert_eq!(frame.sources().len(), 1);
+        assert!(frame.is::<Location>(), "not a location frame");
+
+        let source = frame
+            .sources_mut()
+            .first_mut()
+            .expect("no source frame found");
+
+        let context = source
+            .downcast_mut::<ContextA>()
+            .expect("not a context frame");
+        context.0 += 10;
+        ControlFlow::Break(())
+    });
+    assert!(flow.is_break(), "No location frame found");
+
+    let frame = report.frames().next().expect("No location frame found");
+    assert_eq!(frame.sources().len(), 1);
+    let source = frame.sources().first().expect("no source frame found");
+    let context = source
+        .downcast_ref::<ContextA>()
+        .expect("not a context frame");
+    assert_eq!(context.0, 20);
+}
+
+#[test]
+fn type_id() {
+    let report = create_report().attach_opaque(2_u32);
+    let current = report.current_frame();
+
+    assert_eq!(current.type_id(), TypeId::of::<u32>());
+
+    let context = report
+        .frames()
+        .last()
+        .expect("should have at least a single frame");
+    assert_eq!(context.type_id(), TypeId::of::<RootError>());
+}

data/ext/cargo-vendor/error-stack-0.8.0/tests/test_iter.rs

@@ -0,0 +1,132 @@
+#![cfg_attr(nightly, feature(error_generic_member_access))]
+
+extern crate alloc;
+
+use core::{
+    error::Error,
+    fmt::{Display, Formatter, Write as _},
+    ops::ControlFlow,
+};
+
+mod common;
+use error_stack::{IntoReport as _, Report};
+
+#[derive(Debug)]
+struct Char(char);
+
+impl Display for Char {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> core::fmt::Result {
+        fmt.write_char(self.0)
+    }
+}
+
+impl Error for Char {}
+
+/// Builds the following tree:
+///
+/// ```text
+///     A     G
+///    / \    |
+///   B   E   H
+///  / \  |
+/// C   D F
+/// ```
+///
+/// which will result in this report:
+///
+/// ```text
+/// A
+/// ╰┬▶ B
+///  │  ╰┬▶ C
+///  │   ╰▶ D
+///  ╰▶ E
+///     ╰─▶ F
+/// G
+/// ╰─▶ H
+/// ```
+fn build() -> Report<[Char]> {
+    let mut report_c = Char('C').into_report().expand();
+    let report_d = Char('D').into_report();
+
+    report_c.push(report_d);
+    let mut report_b = report_c.change_context(Char('B')).expand();
+
+    let report_f = Char('F').into_report();
+    let report_e = report_f.change_context(Char('E'));
+
+    report_b.push(report_e);
+
+    let mut report_a = report_b.change_context(Char('A')).expand();
+
+    let report_h = Char('H').into_report();
+    let report_g = report_h.change_context(Char('G'));
+
+    report_a.push(report_g);
+    report_a
+}
+
+/// Try to verify if the topological sorting is working, by trying to verify that:
+///
+/// ```text
+///     A     G
+///    / \    |
+///   B   C   H
+///  / \  |
+/// D   E F
+/// ```
+///
+/// results in `ABDECFGH`.
+#[test]
+fn iter() {
+    let report = build();
+
+    assert_eq!(
+        report
+            .frames()
+            .filter_map(|frame| frame.downcast_ref::<Char>().map(|ch| ch.0))
+            .collect::<Vec<_>>(),
+        ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
+    );
+}
+
+#[test]
+fn iter_mut() {
+    let mut report = build();
+
+    let mut chars = Vec::new();
+    let flow = report.frames_mut(|frame| {
+        if let Some(ch) = frame.downcast_mut::<Char>() {
+            chars.push(ch.0);
+            ch.0 = ch.0.to_ascii_lowercase();
+        }
+        ControlFlow::Continue(())
+    });
+    assert!(flow.is_continue());
+    assert_eq!(chars, ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']);
+
+    assert_eq!(
+        report
+            .frames()
+            .filter_map(|frame| frame.downcast_ref::<Char>().map(|ch| ch.0))
+            .collect::<Vec<_>>(),
+        ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
+    );
+}
+
+#[test]
+fn iter_mut_break() {
+    let mut report = build();
+
+    let mut chars = Vec::new();
+    let flow = report.frames_mut(|frame| {
+        if let Some(ch) = frame.downcast_ref::<Char>() {
+            chars.push(ch.0);
+            if ch.0 == 'D' {
+                return ControlFlow::Break(());
+            }
+        }
+        ControlFlow::Continue(())
+    });
+    assert!(flow.is_break());
+    assert_eq!(chars, ['A', 'B', 'C', 'D']);
+}

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

@@ -2,38 +2,12 @@
 
 mod common;
 
-#[allow(clippy::wildcard_imports)]
 use common::*;
-use error_stack::{bail, ensure, report};
-
-#[test]
-fn report() {
-    let report = capture_error(|| Err(report!(RootError))).attach_printable(PrintableA(0));
-    assert!(report.contains::<RootError>());
-    assert!(report.contains::<PrintableA>());
-    assert!(!report.contains::<PrintableB>());
-    assert_eq!(report.current_context(), &RootError);
-    assert_eq!(report.frames().count(), expect_count(2));
-    assert_eq!(
-        remove_builtin_messages(messages(&report)),
-        remove_builtin_messages(["printable A", "root error"])
-    );
-
-    let report = capture_error(|| Err(report!(report))).attach_printable(PrintableB(0));
-    assert!(report.contains::<RootError>());
-    assert!(report.contains::<PrintableA>());
-    assert!(report.contains::<PrintableB>());
-    assert_eq!(report.current_context(), &RootError);
-    assert_eq!(report.frames().count(), expect_count(3));
-    assert_eq!(
-        remove_builtin_messages(messages(&report)),
-        remove_builtin_messages(["printable B", "printable A", "root error"])
-    );
-}
+use error_stack::{bail, ensure};
 
 #[test]
 fn bail() {
-    let report = capture_error(|| bail!(RootError)).attach_printable(PrintableA(0));
+    let report = capture_error(|| bail!(RootError)).attach(PrintableA(0));
     assert!(report.contains::<RootError>());
     assert!(report.contains::<PrintableA>());
     assert!(!report.contains::<PrintableB>());
@@ -44,7 +18,7 @@ fn bail() {
         remove_builtin_messages(["printable A", "root error"])
     );
 
-    let report = capture_error(|| bail!(report)).attach_printable(PrintableB(0));
+    let report = capture_error(|| bail!(report)).attach(PrintableB(0));
     assert!(report.contains::<RootError>());
     assert!(report.contains::<PrintableA>());
     assert!(report.contains::<PrintableB>());
@@ -66,7 +40,7 @@ fn ensure() {
         ensure!(false, RootError);
         Ok(())
     })
-    .attach_printable(PrintableA(0));
+    .attach(PrintableA(0));
     assert!(report.contains::<RootError>());
     assert!(report.contains::<PrintableA>());
     assert!(!report.contains::<PrintableB>());
@@ -81,7 +55,7 @@ fn ensure() {
         ensure!(false, report);
         Ok(())
     })
-    .attach_printable(PrintableB(0));
+    .attach(PrintableB(0));
     assert!(report.contains::<RootError>());
     assert!(report.contains::<PrintableA>());
     assert!(report.contains::<PrintableB>());

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

@@ -3,7 +3,6 @@
 
 mod common;
 
-#[allow(clippy::wildcard_imports)]
 use common::*;
 use error_stack::Report;
 
@@ -12,7 +11,9 @@ fn request_attachment() {
     let report = create_report();
     assert_eq!(report.request_ref::<u32>().count(), 0);
 
-    let report = report.attach(AttachmentA(10)).attach(AttachmentB(20));
+    let report = report
+        .attach_opaque(AttachmentA(10))
+        .attach_opaque(AttachmentB(20));
 
     let request_a = report.request_ref::<AttachmentA>().collect::<Vec<_>>();
     assert_eq!(request_a.len(), 1);

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

@@ -8,7 +8,7 @@
 
 use insta::assert_ron_snapshot;
 
-use crate::common::{create_report, ContextA, PrintableA, PrintableC};
+use crate::common::{ContextA, PrintableA, PrintableC, create_report};
 
 mod common;
 
@@ -24,7 +24,7 @@ fn prepare() -> impl Drop {
 fn attachment() {
     let _guard = prepare();
 
-    let report = create_report().attach_printable(PrintableA(2));
+    let report = create_report().attach(PrintableA(2));
 
     assert_ron_snapshot!(report);
 }
@@ -34,7 +34,7 @@ fn context() {
     let _guard = prepare();
 
     let report = create_report()
-        .attach_printable(PrintableA(2))
+        .attach(PrintableA(2))
         .change_context(ContextA(2));
 
     assert_ron_snapshot!(report);
@@ -44,27 +44,27 @@ fn context() {
 fn multiple_sources() {
     let _guard = prepare();
 
-    let mut a = create_report().attach_printable(PrintableC(1));
-    let b = create_report().attach_printable(PrintableC(2));
+    let mut report_a = create_report().attach(PrintableC(1)).expand();
+    let report_b = create_report().attach(PrintableC(2));
 
-    a.extend_one(b);
+    report_a.push(report_b);
 
-    let a = a
-        .attach_printable(PrintableC(3))
+    let report_a = report_a
+        .attach(PrintableC(3))
         .change_context(ContextA(2))
-        .attach_printable(PrintableC(4));
+        .attach(PrintableC(4));
 
-    assert_ron_snapshot!(a);
+    assert_ron_snapshot!(report_a);
 }
 
 #[test]
 fn multiple_sources_at_root() {
     let _guard = prepare();
 
-    let mut a = create_report().attach_printable(PrintableC(1));
-    let b = create_report().attach_printable(PrintableC(2));
+    let mut report_a = create_report().attach(PrintableC(1)).expand();
+    let report_b = create_report().attach(PrintableC(2));
 
-    a.extend_one(b);
+    report_a.push(report_b);
 
-    assert_ron_snapshot!(a);
+    assert_ron_snapshot!(report_a);
 }

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

@@ -3,11 +3,10 @@
 
 mod common;
 
-#[allow(clippy::wildcard_imports)]
 use common::*;
-use error_stack::Result;
+use error_stack::Report;
 use tracing_error::{ErrorLayer, SpanTrace};
-use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::layer::SubscriberExt as _;
 
 fn install_tracing_subscriber() {
     static ONCE: std::sync::Once = std::sync::Once::new();
@@ -21,18 +20,18 @@ fn install_tracing_subscriber() {
 
 #[test]
 fn captured() {
-    install_tracing_subscriber();
-
     #[tracing::instrument]
-    fn func_b() -> Result<(), RootError> {
+    fn func_b() -> Result<(), Report<RootError>> {
         create_error()
     }
 
     #[tracing::instrument]
-    fn func_a() -> Result<(), RootError> {
+    fn func_a() -> Result<(), Report<RootError>> {
         func_b()
     }
 
+    install_tracing_subscriber();
+
     let report = capture_error(func_a);
 
     #[cfg(nightly)]
@@ -55,18 +54,18 @@ fn captured() {
 
 #[test]
 fn provided() {
-    install_tracing_subscriber();
-
     #[tracing::instrument]
     fn func_b() -> ErrorA {
         ErrorA::new(0)
     }
 
     #[tracing::instrument]
-    fn func_a() -> Result<(), ErrorA> {
-        Err(error_stack::Report::new(func_b()))
+    fn func_a() -> Result<(), Report<ErrorA>> {
+        Err(Report::new(func_b()))
     }
 
+    install_tracing_subscriber();
+
     let report = capture_error(func_a);
     #[cfg(nightly)]
     let span_trace = report

data/ext/cargo-vendor/error-stack-0.8.0/tests/ui/attach_diagnostics.rs

@@ -0,0 +1,21 @@
+use core::{error::Error, fmt};
+
+use error_stack::Report;
+
+#[derive(Debug)]
+pub struct RootError;
+
+impl fmt::Display for RootError {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.write_str("root error")
+    }
+}
+
+impl Error for RootError {}
+
+#[derive(Debug)]
+struct NotDisplay;
+
+fn main() {
+    let _ = Report::new(RootError).attach(NotDisplay);
+}

data/ext/cargo-vendor/error-stack-0.8.0/tests/ui/attach_diagnostics.stderr

@@ -0,0 +1,23 @@
+error[E0277]: to attach this type to a `Report` it must implement `fmt::Display` and `fmt::Debug`
+  --> tests/ui/attach_diagnostics.rs:20:43
+   |
+20 |     let _ = Report::new(RootError).attach(NotDisplay);
+   |                                    ------ ^^^^^^^^^^ unsatisfied trait bound
+   |                                    |
+   |                                    required by a bound introduced by this call
+   |
+help: the trait `std::fmt::Display` is not implemented for `NotDisplay`
+  --> tests/ui/attach_diagnostics.rs:17:1
+   |
+17 | struct NotDisplay;
+   | ^^^^^^^^^^^^^^^^^
+   = note: if you want to attach a type that is not printable, use `attach_opaque` instead
+   = note: required for `NotDisplay` to implement `error_stack::Attachment`
+note: required by a bound in `error_stack::Report::<C>::attach`
+  --> src/report.rs
+   |
+   |     pub fn attach<A>(mut self, attachment: A) -> Self
+   |            ------ required by a bound in this associated function
+   |     where
+   |         A: Attachment,
+   |            ^^^^^^^^^^ required by this bound in `Report::<C>::attach`

data/ext/cargo-vendor/error-stack-0.8.0/tests/ui/frames_mut_escape.rs

@@ -0,0 +1,28 @@
+//! A `&mut Frame` must not be able to escape the `frames_mut` visitor. Two escaped references
+//! could alias the same frame (directly and through `Frame::sources_mut`), which is the
+//! soundness hole the visitor API exists to close.
+
+use core::{error::Error, fmt, ops::ControlFlow};
+
+use error_stack::{Frame, Report};
+
+#[derive(Debug)]
+pub struct RootError;
+
+impl fmt::Display for RootError {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.write_str("root error")
+    }
+}
+
+impl Error for RootError {}
+
+fn main() {
+    let mut report = Report::new(RootError).attach("attachment");
+
+    let mut escaped: Vec<&mut Frame> = Vec::new();
+    let _ = report.frames_mut(|frame| {
+        escaped.push(frame);
+        ControlFlow::Continue(())
+    });
+}

data/ext/cargo-vendor/error-stack-0.8.0/tests/ui/frames_mut_escape.stderr

@@ -0,0 +1,13 @@
+error[E0521]: borrowed data escapes outside of closure
+  --> tests/ui/frames_mut_escape.rs:25:9
+   |
+23 |     let mut escaped: Vec<&mut Frame> = Vec::new();
+   |         ----------- `escaped` declared here, outside of the closure body
+24 |     let _ = report.frames_mut(|frame| {
+   |                                ----- `frame` is a reference that is only valid in the closure body
+25 |         escaped.push(frame);
+   |         ^^^^^^^^^^^^^^^^^^^ `frame` escapes the closure body here
+   |
+   = note: requirement occurs because of a mutable reference to `Vec<&mut Frame>`
+   = note: mutable references are invariant over their type parameter
+   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance

data/ext/cargo-vendor/error-stack-0.8.0/tests/ui/macro_invalid_args.rs

@@ -0,0 +1,32 @@
+use core::{error::Error, fmt};
+
+use error_stack::{Report, bail, ensure};
+
+#[derive(Debug)]
+pub struct RootError;
+
+impl fmt::Display for RootError {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.write_str("root error")
+    }
+}
+
+impl Error for RootError {}
+
+fn invalid_bail_arg() -> Result<(), Report<RootError>> {
+    bail!("Error")
+}
+
+fn invalid_ensure_error_arg() -> Result<(), Report<RootError>> {
+    let _ = ensure!(true, "Error");
+
+    Ok(())
+}
+
+fn invalid_ensure_condition_arg() -> Result<(), Report<RootError>> {
+    let _ = ensure!("No boolean", RootError);
+
+    Ok(())
+}
+
+fn main() {}