wherror 2.4.0

The same derive(Error) macro thiserror provides + the features you want!
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use std::error::Error as StdError;
use std::io;
use wherror::Error;

#[derive(Error, Debug)]
#[error("implicit source")]
pub struct ImplicitSource {
    source: io::Error,
}

#[derive(Error, Debug)]
#[error("explicit source")]
pub struct ExplicitSource {
    source: String,
    #[source]
    io: io::Error,
}

#[derive(Error, Debug)]
#[error("boxed source")]
pub struct BoxedSource {
    #[source]
    source: Box<dyn StdError + Send + 'static>,
}

#[test]
fn test_implicit_source() {
    let io = io::Error::new(io::ErrorKind::Other, "oh no!");
    let error = ImplicitSource { source: io };
    error.source().unwrap().downcast_ref::<io::Error>().unwrap();
}

#[test]
fn test_explicit_source() {
    let io = io::Error::new(io::ErrorKind::Other, "oh no!");
    let error = ExplicitSource {
        source: String::new(),
        io,
    };
    error.source().unwrap().downcast_ref::<io::Error>().unwrap();
}

#[test]
fn test_boxed_source() {
    let source = Box::new(io::Error::new(io::ErrorKind::Other, "oh no!"));
    let error = BoxedSource { source };
    error.source().unwrap().downcast_ref::<io::Error>().unwrap();
}

macro_rules! error_from_macro {
    ($($variants:tt)*) => {
        #[derive(Error)]
        #[derive(Debug)]
        pub enum MacroSource {
            $($variants)*
        }
    }
}

// Test that we generate impls with the proper hygiene
#[rustfmt::skip]
error_from_macro! {
    #[error("Something")]
    Variant(#[from] io::Error)
}

#[test]
fn test_not_source() {
    #[derive(Error, Debug)]
    #[error("{source} ==> {destination}")]
    pub struct NotSource {
        r#source: char,
        destination: char,
    }

    let error = NotSource {
        source: 'S',
        destination: 'D',
    };
    assert_eq!(error.to_string(), "S ==> D");
    assert!(error.source().is_none());
}

#[test]
fn test_from_non_error_no_source() {
    #[derive(Debug)]
    struct Status(#[allow(unused)] u16);

    #[derive(Error, Debug)]
    #[error(debug)]
    enum AppError {
        WebSocket(#[from(no_source)] Status),
        String(#[from(no_source)] String),
    }

    let e1 = AppError::WebSocket(Status(1011));
    let e2: AppError = "test error".to_string().into();
    assert_eq!(e1.to_string(), "WebSocket(Status(1011))");
    assert!(StdError::source(&e1).is_none());
    assert_eq!(e2.to_string(), r#"String("test error")"#);
    assert!(StdError::source(&e2).is_none());
}