wallee 0.2.4

Flexible concrete Error type built on std::error::Error with caller location tracking
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Tagged dispatch mechanism for resolving the behavior of `wallee!($expr)`.
//
// When wallee! is given a single expr argument to turn into wallee::Error, we
// want the resulting Error to pick up the input's implementation of source()
// and backtrace() if it has a std::error::Error impl, otherwise require nothing
// more than Display and Debug.
//
// Expressed in terms of specialization, we want something like:
//
//     trait WalleeNew {
//         fn new(self) -> Error;
//     }
//
//     impl<T> WalleeNew for T
//     where
//         T: Display + Debug + Send + Sync + 'static,
//     {
//         default fn new(self) -> Error {
//             /* no std error impl */
//         }
//     }
//
//     impl<T> WalleeNew for T
//     where
//         T: std::error::Error + Send + Sync + 'static,
//     {
//         fn new(self) -> Error {
//             /* use std error's source() and backtrace() */
//         }
//     }
//
// Since specialization is not stable yet, instead we rely on autoref behavior
// of method resolution to perform tagged dispatch. Here we have two traits
// AdhocKind and TraitKind that both have an wallee_kind() method. AdhocKind is
// implemented whether or not the caller's type has a std error impl, while
// TraitKind is implemented only when a std error impl does exist. The ambiguity
// is resolved by AdhocKind requiring an extra autoref so that it has lower
// precedence.
//
// The wallee! macro will set up the call in this form:
//
//     #[allow(unused_imports)]
//     use $crate::__private::{AdhocKind, TraitKind};
//     let error = $msg;
//     (&error).wallee_kind().new(error)

use crate::Error;
use core::fmt::{Debug, Display};

use crate::StdError;

pub struct MakeDebug;

#[doc(hidden)]
pub trait DebugKind: Sized {
    #[inline]
    fn wallee_kind(&self) -> MakeDebug {
        MakeDebug
    }
}

impl<T> DebugKind for &T where T: ?Sized + Display + Debug + Send + Sync + 'static {}

impl MakeDebug {
    #[cold]
    #[track_caller]
    pub fn make<M>(self, message: M) -> Error
    where
        M: Display + Debug + Send + Sync + 'static,
    {
        Error::from_debug(message, backtrace!())
    }
}

pub struct MakeStd;

#[doc(hidden)]
pub trait StdKind: Sized {
    #[inline]
    fn wallee_kind(&self) -> MakeStd {
        MakeStd
    }
}

impl<E> StdKind for E where E: StdError + Send + Sync + 'static {}

impl MakeStd {
    #[cold]
    #[track_caller]
    pub fn make<E>(self, error: E) -> Error
    where
        E: StdError + Send + Sync + 'static,
    {
        Error::new(error)
    }
}

pub struct MakeError;

#[doc(hidden)]
pub trait ErrorKind: Sized {
    #[inline]
    fn wallee_kind(&self) -> MakeError {
        MakeError
    }
}

impl ErrorKind for Error {}

impl MakeError {
    #[cold]
    #[track_caller]
    pub fn make(self, error: Error) -> Error {
        error
    }
}

pub struct Boxed;

#[doc(hidden)]
pub trait BoxedKind: Sized {
    #[inline]
    fn wallee_kind(&self) -> Boxed {
        Boxed
    }
}

impl BoxedKind for Box<dyn StdError + Send + Sync> {}

impl Boxed {
    #[cold]
    #[track_caller]
    pub fn make(self, error: Box<dyn StdError + Send + Sync>) -> Error {
        let backtrace = backtrace_if_absent!(&*error);
        Error::from_boxed(error, backtrace)
    }
}