thistrace 0.1.0

Callsite provenance (file/line/col) for thiserror #[from] conversions via #[track_caller]
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

use thistrace::{origin, HasTrace, OneLineTrace};

#[derive(thiserror::Error, Debug)]
#[error("leaf boom")]
struct LeafError;

#[derive(thiserror::Error, Debug)]
enum AppError {
    #[error("leaf")]
    Leaf {
        #[source]
        source: thistrace::Origin<LeafError>,
        trace: thistrace::Trace,
    },

    #[error("bubble")]
    Bubble {
        #[source]
        source: Box<AppError>,
        trace: thistrace::Trace,
    },
}

impl HasTrace for AppError {
    fn trace(&self) -> Option<&thistrace::Trace> {
        match self {
            Self::Leaf { trace, .. } => Some(trace),
            Self::Bubble { trace, .. } => Some(trace),
        }
    }
}

impl From<thistrace::Origin<LeafError>> for AppError {
    #[track_caller]
    fn from(source: thistrace::Origin<LeafError>) -> Self {
        let (leaf, mut trace) = source.into_parts();
        let loc = std::panic::Location::caller();
        trace.push(thistrace::Frame::from_location(loc));
        Self::Leaf {
            source: thistrace::Origin::new(leaf, trace.clone()),
            trace,
        }
    }
}

impl From<thistrace::Bubbled<AppError>> for AppError {
    fn from(source: thistrace::Bubbled<AppError>) -> Self {
        let (inner, trace) = source.into_parts();
        Self::Bubble {
            source: Box::new(inner),
            trace,
        }
    }
}

fn make_leaf() -> Result<(), thistrace::Origin<LeafError>> {
    Err(origin(LeafError))
}

fn layer1() -> Result<(), AppError> {
    make_leaf()?;
    Ok(())
}

fn layer2() -> Result<(), AppError> {
    layer1().map_err(thistrace::bubble_into!(AppError))?;
    Ok(())
}

fn layer3() -> Result<(), AppError> {
    layer2().map_err(thistrace::bubble_into!(AppError))?;
    Ok(())
}

#[test]
fn single_enum_multiple_layers_can_accumulate_frames() {
    let err = layer3().unwrap_err();
    let frames = thistrace::trace_frames(&err);

    // leaf origin + layer1 conversion + layer2 bubble + layer3 bubble
    assert!(frames.len() >= 4);

    let one_line = format!("{}", OneLineTrace::new(&err));
    assert!(!one_line.contains('\n'));
}