code_ownership 2.1.4 → 2.2.0

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

@@ -3,16 +3,16 @@
 #![allow(clippy::std_instead_of_core)]
 mod common;
 
-#[allow(clippy::wildcard_imports)]
 use common::*;
-use error_stack::fmt::{Charset, ColorMode};
-#[allow(unused_imports)]
-use error_stack::Report;
+use error_stack::{
+    Report,
+    fmt::{Charset, ColorMode},
+};
 use insta::assert_snapshot;
 #[cfg(feature = "spantrace")]
 use tracing_error::ErrorLayer;
 #[cfg(feature = "spantrace")]
-use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::layer::SubscriberExt as _;
 
 #[cfg(feature = "spantrace")]
 fn setup_tracing() {
@@ -50,7 +50,10 @@ fn setup() {
 }
 
 fn snap_suffix() -> String {
-    #[allow(unused_mut)]
+    #[cfg_attr(
+        not(any(feature = "backtrace", feature = "spantrace")),
+        expect(unused_mut)
+    )]
     let mut suffix: Vec<&'static str> = vec![];
 
     #[cfg(feature = "spantrace")]
@@ -70,12 +73,12 @@ fn snap_suffix() -> String {
 #[cfg(feature = "spantrace")]
 pub fn create_report() -> Report<RootError> {
     #[tracing::instrument]
-    fn func_b() -> error_stack::Result<(), RootError> {
+    fn func_b() -> Result<(), Report<RootError>> {
         create_error()
     }
 
     #[tracing::instrument]
-    fn func_a() -> error_stack::Result<(), RootError> {
+    fn func_a() -> Result<(), Report<RootError>> {
         func_b()
     }
 
@@ -158,54 +161,54 @@ fn prepare(suffix: bool) -> impl Drop {
 ///                         root error 4
 /// ```
 ///
-/// `P = Printable`, `C = Context`
+/// Legend: `P = Printable`, `C = Context`.
 fn create_sources_nested() -> Report<ContextA> {
     let r4 = create_report()
         .change_context(ContextA(5))
-        .attach_printable("15")
-        .attach_printable("14");
+        .attach("15")
+        .attach("14");
 
     let r6 = create_report()
         .change_context(ContextA(7))
         .change_context(ContextA(6))
-        .attach_printable("12");
+        .attach("12");
 
-    let r5 = create_report()
-        .change_context(ContextA(9))
-        .attach_printable("11");
+    let r5 = create_report().change_context(ContextA(9)).attach("11");
 
     let mut r3 = create_report()
         .change_context(ContextA(8))
-        .attach_printable("13");
+        .attach("13")
+        .expand();
 
-    r3.extend_one(r4);
-    let r3 = r3.attach_printable("10").attach_printable("16");
+    r3.push(r4);
+    let r3 = r3.attach("10").attach("16");
 
-    let mut r2 = create_report().change_context(ContextA(4));
+    let mut r2 = create_report().change_context(ContextA(4)).expand();
 
-    r2.extend_one(r3);
-    r2.extend_one(r5);
-    r2.extend_one(r6);
+    r2.append(r3);
+    r2.push(r5);
+    r2.push(r6);
 
     let r2 = r2
-        .attach_printable("9")
-        .attach_printable("8")
+        .attach("9")
+        .attach("8")
         .change_context(ContextA(3))
-        .attach_printable("7")
+        .attach("7")
         .change_context(ContextA(10))
-        .attach_printable("5");
+        .attach("5");
 
     let mut r1 = create_report()
-        .attach_printable("6")
+        .attach("6")
         .change_context(ContextA(2))
-        .attach_printable("4");
+        .attach("4")
+        .expand();
 
-    r1.extend_one(r2);
+    r1.push(r2);
 
-    r1.attach_printable("3")
+    r1.attach("3")
         .change_context(ContextA(1))
-        .attach_printable("2")
-        .attach_printable("1")
+        .attach("2")
+        .attach("1")
 }
 
 /// This is the main test, to test all different parts at once,
@@ -257,7 +260,6 @@ mod full {
         panic::Location,
     };
 
-    #[allow(clippy::wildcard_imports)]
     use super::*;
 
     #[test]
@@ -265,14 +267,14 @@ mod full {
         let _guard = prepare(false);
 
         let report = create_report()
-            .attach_printable(PrintableA(0))
-            .attach(AttachmentA)
-            .attach(AttachmentB)
+            .attach(PrintableA(0))
+            .attach_opaque(AttachmentA)
+            .attach_opaque(AttachmentB)
             .change_context(ContextA(0))
-            .attach_printable(PrintableB(0))
-            .attach(AttachmentB)
+            .attach(PrintableB(0))
+            .attach_opaque(AttachmentB)
             .change_context(ContextB(0))
-            .attach_printable("printable C");
+            .attach("printable C");
 
         assert_snapshot!(format!("{report:?}"));
     }
@@ -282,14 +284,14 @@ mod full {
         let _guard = prepare(false);
 
         let report = create_report()
-            .attach_printable(PrintableA(0))
-            .attach(AttachmentA)
-            .attach(AttachmentB)
+            .attach(PrintableA(0))
+            .attach_opaque(AttachmentA)
+            .attach_opaque(AttachmentB)
             .change_context(ContextA(0))
-            .attach_printable(PrintableB(0))
-            .attach(AttachmentB)
+            .attach(PrintableB(0))
+            .attach_opaque(AttachmentB)
             .change_context(ContextB(0))
-            .attach_printable("printable C");
+            .attach("printable C");
 
         assert_snapshot!(format!("{report:#?}"));
     }
@@ -298,8 +300,8 @@ mod full {
     struct ContextC;
 
     impl Display for ContextC {
-        fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-            f.write_str("A multiline\ncontext that might have\na bit more info")
+        fn fmt(&self, fmt: &mut Formatter<'_>) -> core::fmt::Result {
+            fmt.write_str("A multiline\ncontext that might have\na bit more info")
         }
     }
 
@@ -311,10 +313,10 @@ mod full {
 
         let report = Report::new(ContextC)
             .change_context(ContextC)
-            .attach_printable(PrintableB(0))
-            .attach(AttachmentB)
+            .attach(PrintableB(0))
+            .attach_opaque(AttachmentB)
             .change_context(ContextB(0))
-            .attach_printable("printable C");
+            .attach("printable C");
 
         assert_snapshot!(format!("{report:#?}"));
     }
@@ -324,13 +326,13 @@ mod full {
         let _guard = prepare(false);
 
         let report = create_report()
-            .attach_printable("A multiline\nattachment\nthat might have some\nadditional info")
-            .attach_printable("A multiline\nattachment\nthat might have some\nadditional info");
+            .attach("A multiline\nattachment\nthat might have some\nadditional info")
+            .attach("A multiline\nattachment\nthat might have some\nadditional info");
 
         assert_snapshot!(format!("{report:#?}"));
     }
 
-    /// Generate the `Debug` for
+    /// Generate the `Debug` for:
     ///
     /// ```text
     ///         [A] B
@@ -349,17 +351,17 @@ mod full {
     fn sources() {
         let _guard = prepare(false);
 
-        let mut root1 = create_report().attach_printable(PrintableA(1));
-        let root2 = create_report().attach_printable(PrintableB(2));
-        let root3 = create_report().attach_printable(PrintableB(3));
+        let mut root1 = create_report().attach(PrintableA(1)).expand();
+        let root2 = create_report().attach(PrintableB(2));
+        let root3 = create_report().attach(PrintableB(3));
 
-        root1.extend_one(root2);
-        root1.extend_one(root3);
+        root1.push(root2);
+        root1.push(root3);
 
         let report = root1
-            .attach(AttachmentA(1))
+            .attach_opaque(AttachmentA(1))
             .change_context(ContextA(2))
-            .attach(AttachmentB(2));
+            .attach_opaque(AttachmentB(2));
 
         assert_snapshot!(format!("{report:?}"));
     }
@@ -387,20 +389,20 @@ mod full {
         let _guard = prepare(false);
 
         let report = {
-            let mut report = create_report().attach_printable(PrintableA(1));
+            let mut report = create_report().attach(PrintableA(1)).expand();
 
-            report.extend_one({
-                let mut report = create_report().attach_printable(PrintableB(2));
+            report.append({
+                let mut report = create_report().attach(PrintableB(2)).expand();
 
-                report.extend_one(create_report().attach_printable(PrintableB(3)));
+                report.push(create_report().attach(PrintableB(3)));
 
-                report.attach_printable(PrintableA(4))
+                report.attach(PrintableA(4))
             });
 
             report
-                .attach(AttachmentA(1))
+                .attach_opaque(AttachmentA(1))
                 .change_context(ContextA(2))
-                .attach(AttachmentB(2))
+                .attach_opaque(AttachmentB(2))
         };
 
         assert_snapshot!(format!("{report:?}"));
@@ -410,24 +412,22 @@ mod full {
     fn complex() {
         let _guard = prepare(false);
 
-        let mut report = create_report().attach_printable(PrintableA(0));
-        report.extend_one({
-            let mut report = create_report().attach_printable(PrintableB(1));
+        let mut report = create_report().attach(PrintableA(0)).expand();
+        report.append({
+            let mut report = create_report().attach(PrintableB(1)).expand();
 
-            report.extend_one(
+            report.push(
                 create_report()
-                    .attach(AttachmentB(0))
-                    .attach(AttachmentA(1))
-                    .attach_printable(PrintableB(1)),
+                    .attach_opaque(AttachmentB(0))
+                    .attach_opaque(AttachmentA(1))
+                    .attach(PrintableB(1)),
             );
 
-            report.attach(AttachmentA(2)).attach_printable("Test")
+            report.attach_opaque(AttachmentA(2)).attach("Test")
         });
 
         // force the generation of a tree node
-        let report = report
-            .change_context(ContextA(2))
-            .attach_printable(PrintableA(2));
+        let report = report.change_context(ContextA(2)).attach(PrintableA(2));
 
         assert_snapshot!(format!("{report:?}"));
     }
@@ -436,7 +436,7 @@ mod full {
     fn hook() {
         let _guard = prepare(false);
 
-        let report = create_report().attach(2_u32);
+        let report = create_report().attach_opaque(2_u32);
 
         Report::install_debug_hook::<u32>(|_, context| {
             context.push_body("unsigned 32bit integer");
@@ -449,7 +449,7 @@ mod full {
     fn hook_context() {
         let _guard = prepare(false);
 
-        let report = create_report().attach(2_u32);
+        let report = create_report().attach_opaque(2_u32);
 
         Report::install_debug_hook::<u32>(|_, context| {
             let idx = context.increment_counter();
@@ -463,7 +463,7 @@ mod full {
     fn hook_for_context() {
         let _guard = prepare(false);
 
-        let report = create_report().attach(2_u32);
+        let report = create_report().attach_opaque(2_u32);
 
         Report::install_debug_hook::<RootError>(|_, _| {
             // This should not be displayed as `RootError` is only used as `Context`, never as
@@ -478,7 +478,7 @@ mod full {
     fn hook_multiple() {
         let _guard = prepare(false);
 
-        let report = create_report().attach(1_u32).attach(2_u64);
+        let report = create_report().attach_opaque(1_u32).attach_opaque(2_u64);
 
         Report::install_debug_hook::<u32>(|_, context| {
             context.push_body("unsigned 32bit integer");
@@ -495,9 +495,9 @@ mod full {
         let _guard = prepare(false);
 
         let report = create_report() //
-            .attach(1_u32)
-            .attach(2_u32)
-            .attach(3_u32);
+            .attach_opaque(1_u32)
+            .attach_opaque(2_u32)
+            .attach_opaque(3_u32);
 
         Report::install_debug_hook::<u32>(|_, context| {
             let idx = context.decrement_counter();
@@ -512,9 +512,9 @@ mod full {
         let _guard = prepare(false);
 
         let report = create_report() //
-            .attach(1_u32)
-            .attach(2_u32)
-            .attach(3_u32);
+            .attach_opaque(1_u32)
+            .attach_opaque(2_u32)
+            .attach_opaque(3_u32);
 
         Report::install_debug_hook::<u32>(|_, context| {
             let idx = context.increment_counter();
@@ -528,7 +528,7 @@ mod full {
     fn hook_alternate() {
         let _guard = prepare(false);
 
-        let report = create_report().attach(2_u64);
+        let report = create_report().attach_opaque(2_u64);
 
         Report::install_debug_hook::<u64>(|_, context| {
             if context.alternate() {
@@ -563,8 +563,8 @@ mod full {
 
     #[cfg(nightly)]
     impl Display for ContextD {
-        fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
-            f.write_str("context D")
+        fn fmt(&self, fmt: &mut Formatter<'_>) -> core::fmt::Result {
+            fmt.write_str("context D")
         }
     }
 

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

@@ -2,17 +2,16 @@
 
 mod common;
 
-#[allow(clippy::wildcard_imports)]
 use common::*;
 
 #[test]
 fn normal() {
     let report = create_report()
-        .attach_printable(PrintableA(0))
-        .attach(AttachmentA)
+        .attach(PrintableA(0))
+        .attach_opaque(AttachmentA)
         .change_context(ContextA(0))
-        .attach_printable(PrintableB(0))
-        .attach(AttachmentB)
+        .attach(PrintableB(0))
+        .attach_opaque(AttachmentB)
         .change_context(ContextB(0));
 
     assert_eq!(report.to_string(), "context B");
@@ -21,11 +20,11 @@ fn normal() {
 #[test]
 fn extended() {
     let report = create_report()
-        .attach_printable(PrintableA(0))
-        .attach(AttachmentA)
+        .attach(PrintableA(0))
+        .attach_opaque(AttachmentA)
         .change_context(ContextA(0))
-        .attach_printable(PrintableB(0))
-        .attach(AttachmentB)
+        .attach(PrintableB(0))
+        .attach_opaque(AttachmentB)
         .change_context(ContextB(0));
 
     assert_eq!(format!("{report:#}"), "context B: context A: root error");

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

@@ -0,0 +1,101 @@
+#![cfg_attr(nightly, feature(error_generic_member_access))]
+
+mod common;
+
+use common::*;
+
+#[test]
+fn downcast_ref() {
+    let mut report = create_report();
+    assert!(report.contains::<RootError>());
+
+    assert!(!report.contains::<AttachmentA>());
+    report = report.attach_opaque(AttachmentA(10));
+    assert!(report.contains::<AttachmentA>());
+
+    let attachment = report
+        .downcast_ref::<AttachmentA>()
+        .expect("Attachment not found");
+    assert_eq!(attachment.0, 10);
+}
+
+#[test]
+fn downcast_mut() {
+    let mut report = create_report();
+    assert!(report.contains::<RootError>());
+
+    assert!(!report.contains::<AttachmentA>());
+    report = report.attach_opaque(AttachmentA(10));
+    assert!(report.contains::<AttachmentA>());
+
+    let attachment = report
+        .downcast_mut::<AttachmentA>()
+        .expect("Attachment not found");
+    attachment.0 += 10;
+
+    let attachment = report
+        .downcast_ref::<AttachmentA>()
+        .expect("Attachment not found");
+    assert_eq!(attachment.0, 20);
+}
+
+#[test]
+fn downcast_mut_deep() {
+    let mut report = create_report()
+        .attach_opaque(AttachmentA(10))
+        .change_context(ContextA(0))
+        .attach_opaque(AttachmentB(0));
+
+    let attachment = report
+        .downcast_mut::<AttachmentA>()
+        .expect("Attachment not found");
+    attachment.0 += 10;
+
+    let attachment = report
+        .downcast_ref::<AttachmentA>()
+        .expect("Attachment not found");
+    assert_eq!(attachment.0, 20);
+}
+
+#[test]
+fn downcast_mut_second_root() {
+    let mut report = create_report().expand();
+    report.push(create_report().attach_opaque(AttachmentA(10)));
+
+    let attachment = report
+        .downcast_mut::<AttachmentA>()
+        .expect("Attachment not found");
+    attachment.0 += 10;
+
+    let attachment = report
+        .downcast_ref::<AttachmentA>()
+        .expect("Attachment not found");
+    assert_eq!(attachment.0, 20);
+}
+
+#[test]
+fn downcast_mut_returns_outermost() {
+    let mut report = create_report()
+        .attach_opaque(AttachmentA(1))
+        .attach_opaque(AttachmentB(2))
+        .attach_opaque(AttachmentA(3));
+
+    let attachment = report
+        .downcast_mut::<AttachmentA>()
+        .expect("Attachment not found");
+    assert_eq!(attachment.0, 3);
+    attachment.0 = 30;
+
+    let values: Vec<_> = report
+        .frames()
+        .filter_map(|frame| frame.downcast_ref::<AttachmentA>())
+        .map(|attachment| attachment.0)
+        .collect();
+    assert_eq!(values, [30, 1]);
+}
+
+#[test]
+fn downcast_mut_miss() {
+    let mut report = create_report().attach_opaque(AttachmentA(10));
+    assert!(report.downcast_mut::<AttachmentB>().is_none());
+}

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

@@ -0,0 +1,99 @@
+#![cfg_attr(nightly, feature(error_generic_member_access))]
+
+mod common;
+use core::{
+    error::Error,
+    fmt::{Display, Formatter},
+};
+
+use common::*;
+use error_stack::{IntoReport as _, Report};
+
+#[derive(Debug)]
+struct MyError;
+
+impl Display for MyError {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> core::fmt::Result {
+        fmt.write_str("Error")
+    }
+}
+
+impl Error for MyError {}
+
+#[test]
+fn push_append() {
+    let mut err1 = MyError.into_report().attach("Not Supported").expand();
+    let err2 = MyError.into_report().attach("Not Supported");
+    let mut err3 = MyError.into_report().attach("Not Supported").expand();
+
+    let count = expect_count(2) * 3;
+
+    err1.push(err2);
+    err3.append(err1);
+
+    assert_eq!(err3.current_frames().len(), 3);
+    assert_eq!(err3.frames().count(), count);
+}
+
+#[test]
+fn push() {
+    let mut err1 = MyError.into_report().attach("Not Supported").expand();
+    let err2 = MyError.into_report().attach("Not Supported");
+    let err3 = MyError.into_report().attach("Not Supported");
+
+    let count = expect_count(2) * 3;
+
+    err1.push(err2);
+    err1.push(err3);
+
+    assert_eq!(err1.current_frames().len(), 3);
+    assert_eq!(err1.frames().count(), count);
+}
+
+#[test]
+fn extend() {
+    let mut err1 = MyError.into_report().attach("Not Supported").expand();
+    let err2 = MyError.into_report().attach("Not Supported");
+    let err3 = MyError.into_report().attach("Not Supported");
+
+    err1.extend([err2, err3]);
+    assert_eq!(err1.current_frames().len(), 3);
+    assert_eq!(err1.frames().count(), expect_count(2) * 3);
+}
+
+#[test]
+fn collect_single() {
+    let report: Option<Report<[MyError]>> = vec![
+        MyError.into_report(),
+        MyError.into_report(),
+        MyError.into_report(),
+    ]
+    .into_iter()
+    .collect();
+
+    let report = report.expect("should be some");
+    assert_eq!(report.current_frames().len(), 3);
+    assert_eq!(report.frames().count(), expect_count(1) * 3);
+}
+
+#[test]
+fn collect_multiple() {
+    let report: Option<Report<[MyError]>> = vec![
+        MyError.into_report().expand(),
+        MyError.into_report().expand(),
+        MyError.into_report().expand(),
+    ]
+    .into_iter()
+    .collect();
+
+    let report = report.expect("should be some");
+    assert_eq!(report.current_frames().len(), 3);
+    assert_eq!(report.frames().count(), expect_count(1) * 3);
+}
+
+#[test]
+fn collect_none() {
+    let report: Option<Report<[MyError]>> = ([] as [Report<MyError>; 0]).into_iter().collect();
+
+    assert!(report.is_none());
+}