pseudo-backtrace 0.2.1

Utilities for constructing stack-like error chains with caller locations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use pseudo_backtrace::{LocatedError, StackError, StackErrorExt};
use thiserror::Error;

#[derive(Debug)]
struct Leaf;

impl core::fmt::Display for Leaf {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.write_str("leaf")
    }
}

impl core::error::Error for Leaf {}

// Pattern 1: explicit #[location] + #[source] on the same LocatedError field
#[derive(Debug, StackError)]
struct ExplictBoth {
    #[location]
    #[source] // treated as stacked by default
    inner: LocatedError<Leaf>,
}

impl core::fmt::Display for ExplictBoth {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.write_str("explict-both")
    }
}

impl core::error::Error for ExplictBoth {
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        Some(&self.inner)
    }
}

impl From<LocatedError<Leaf>> for ExplictBoth {
    fn from(inner: LocatedError<Leaf>) -> Self {
        Self { inner }
    }
}

// Pattern 2: implicit location from source when the source is LocatedError<_>
#[derive(Debug, StackError)]
struct ImplicitFromSource {
    #[source]
    inner: LocatedError<Leaf>,
}

impl core::fmt::Display for ImplicitFromSource {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.write_str("implicit-from-source")
    }
}

impl core::error::Error for ImplicitFromSource {
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        Some(&self.inner)
    }
}

fn main() {
    let leaf = Leaf;
    let located: LocatedError<Leaf> = LocatedError::from(leaf);
    let a = ExplictBoth::from(located);
    println!("{}", a.to_chain());

    let located2: LocatedError<Leaf> = LocatedError::from(Leaf);
    let b = ImplicitFromSource { inner: located2 };
    println!("{}", b.to_chain());

    // Enum pattern: put only LocatedError inside a variant (works nicely with thiserror's transparent)
    #[derive(Debug, Error, StackError)]
    enum TransparentEnum {
        // thiserror transparent variant: uses inner Display and Error::source
        // pseudo-backtrace: uses inner.location() for StackError::location via fallback
        #[error(transparent)]
        IoTransparent(LocatedError<Leaf>),

        // non-transparent but still only LocatedError inside: add #[source] to link as next
        #[error("io error")]
        IoWithSource(#[source] LocatedError<Leaf>),
    }

    let e1 = TransparentEnum::IoTransparent(LocatedError::from(Leaf));
    println!("{}", e1.to_chain());

    let e2 = TransparentEnum::IoWithSource(LocatedError::from(Leaf));
    println!("{}", e2.to_chain());
}