[go: up one dir, main page]

eyre 0.5.0

Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#![allow(missing_debug_implementations, missing_docs)]
// Tagged dispatch mechanism for resolving the behavior of `eyre!($expr)`.
//
// When eyre! is given a single expr argument to turn into eyre::Report, we
// want the resulting Report 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 EyreNew {
//         fn new(self) -> Report;
//     }
//
//     impl<T> EyreNew for T
//     where
//         T: Display + Debug + Send + Sync + 'static,
//     {
//         default fn new(self) -> Report {
//             /* no std error impl */
//         }
//     }
//
//     impl<T> EyreNew for T
//     where
//         T: std::error::Error + Send + Sync + 'static,
//     {
//         fn new(self) -> Report {
//             /* 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 eyre_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 eyre! macro will set up the call in this form:
//
//     #[allow(unused_imports)]
//     use $crate::private::{AdhocKind, TraitKind};
//     let error = $msg;
//     (&error).eyre_kind().new(error)

use crate::{EyreHandler, Report};
use core::fmt::{Debug, Display};

#[cfg(feature = "std")]
use crate::StdError;

pub struct Adhoc;

pub trait AdhocKind: Sized {
    #[inline]
    fn eyre_kind(&self) -> Adhoc {
        Adhoc
    }
}

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

impl Adhoc {
    pub fn new<M, H: EyreHandler>(self, message: M) -> Report<H>
    where
        M: Display + Debug + Send + Sync + 'static,
    {
        Report::from_adhoc(message)
    }
}

pub struct Trait<H>(std::marker::PhantomData<H>);

pub trait TraitKind<H>: Sized {
    #[inline]
    fn eyre_kind(&self) -> Trait<H> {
        Trait(std::marker::PhantomData)
    }
}

impl<E, H> TraitKind<H> for E
where
    E: Into<Report<H>>,
    H: EyreHandler,
{
}

impl<H> Trait<H> {
    pub fn new<E>(self, error: E) -> Report<H>
    where
        E: Into<Report<H>>,
        H: EyreHandler,
    {
        error.into()
    }
}

#[cfg(feature = "std")]
pub struct Boxed;

#[cfg(feature = "std")]
pub trait BoxedKind: Sized {
    #[inline]
    fn eyre_kind(&self) -> Boxed {
        Boxed
    }
}

#[cfg(feature = "std")]
impl BoxedKind for Box<dyn StdError + Send + Sync> {}

#[cfg(feature = "std")]
impl Boxed {
    pub fn new<H: EyreHandler>(self, error: Box<dyn StdError + Send + Sync>) -> Report<H> {
        Report::from_boxed(error)
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::eyre;
    use std::num::ParseIntError;

    struct NonDefaultHandler;

    impl EyreHandler for NonDefaultHandler {
        #[allow(unused_variables)]
        fn default(error: &(dyn StdError + 'static)) -> Self {
            Self
        }

        fn debug(
            &self,
            _error: &(dyn StdError + 'static),
            _f: &mut core::fmt::Formatter<'_>,
        ) -> core::fmt::Result {
            Ok(())
        }
    }

    fn _parse(s: &str) -> Result<i32, ParseIntError> {
        s.parse::<i32>()
    }

    fn _throw_error() -> Result<(), Report<NonDefaultHandler>> {
        match _parse("abc") {
            Ok(_) => Ok(()),
            Err(e) => Err(eyre!(e).wrap_err("try parsing an actual number")),
        }
    }
}