/rust/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.96/src/kind.rs
Line | Count | Source |
1 | | // Tagged dispatch mechanism for resolving the behavior of `anyhow!($expr)`. |
2 | | // |
3 | | // When anyhow! is given a single expr argument to turn into anyhow::Error, we |
4 | | // want the resulting Error to pick up the input's implementation of source() |
5 | | // and backtrace() if it has a std::error::Error impl, otherwise require nothing |
6 | | // more than Display and Debug. |
7 | | // |
8 | | // Expressed in terms of specialization, we want something like: |
9 | | // |
10 | | // trait AnyhowNew { |
11 | | // fn new(self) -> Error; |
12 | | // } |
13 | | // |
14 | | // impl<T> AnyhowNew for T |
15 | | // where |
16 | | // T: Display + Debug + Send + Sync + 'static, |
17 | | // { |
18 | | // default fn new(self) -> Error { |
19 | | // /* no std error impl */ |
20 | | // } |
21 | | // } |
22 | | // |
23 | | // impl<T> AnyhowNew for T |
24 | | // where |
25 | | // T: std::error::Error + Send + Sync + 'static, |
26 | | // { |
27 | | // fn new(self) -> Error { |
28 | | // /* use std error's source() and backtrace() */ |
29 | | // } |
30 | | // } |
31 | | // |
32 | | // Since specialization is not stable yet, instead we rely on autoref behavior |
33 | | // of method resolution to perform tagged dispatch. Here we have two traits |
34 | | // AdhocKind and TraitKind that both have an anyhow_kind() method. AdhocKind is |
35 | | // implemented whether or not the caller's type has a std error impl, while |
36 | | // TraitKind is implemented only when a std error impl does exist. The ambiguity |
37 | | // is resolved by AdhocKind requiring an extra autoref so that it has lower |
38 | | // precedence. |
39 | | // |
40 | | // The anyhow! macro will set up the call in this form: |
41 | | // |
42 | | // #[allow(unused_imports)] |
43 | | // use $crate::__private::{AdhocKind, TraitKind}; |
44 | | // let error = $msg; |
45 | | // (&error).anyhow_kind().new(error) |
46 | | |
47 | | use crate::Error; |
48 | | use core::fmt::{Debug, Display}; |
49 | | |
50 | | #[cfg(any(feature = "std", not(anyhow_no_core_error)))] |
51 | | use crate::StdError; |
52 | | #[cfg(any(feature = "std", not(anyhow_no_core_error)))] |
53 | | use alloc::boxed::Box; |
54 | | |
55 | | pub struct Adhoc; |
56 | | |
57 | | #[doc(hidden)] |
58 | | pub trait AdhocKind: Sized { |
59 | | #[inline] |
60 | 0 | fn anyhow_kind(&self) -> Adhoc { |
61 | 0 | Adhoc |
62 | 0 | } Unexecuted instantiation: <&alloc::string::String as anyhow::kind::AdhocKind>::anyhow_kind Unexecuted instantiation: <_ as anyhow::kind::AdhocKind>::anyhow_kind |
63 | | } |
64 | | |
65 | | impl<T> AdhocKind for &T where T: ?Sized + Display + Debug + Send + Sync + 'static {} |
66 | | |
67 | | impl Adhoc { |
68 | | #[cold] |
69 | 0 | pub fn new<M>(self, message: M) -> Error |
70 | 0 | where |
71 | 0 | M: Display + Debug + Send + Sync + 'static, |
72 | | { |
73 | 0 | Error::construct_from_adhoc(message, backtrace!()) |
74 | 0 | } Unexecuted instantiation: <anyhow::kind::Adhoc>::new::<alloc::string::String> Unexecuted instantiation: <anyhow::kind::Adhoc>::new::<_> |
75 | | } |
76 | | |
77 | | pub struct Trait; |
78 | | |
79 | | #[doc(hidden)] |
80 | | pub trait TraitKind: Sized { |
81 | | #[inline] |
82 | 0 | fn anyhow_kind(&self) -> Trait { |
83 | 0 | Trait |
84 | 0 | } Unexecuted instantiation: <ztunnel::xds::Error as anyhow::kind::TraitKind>::anyhow_kind Unexecuted instantiation: <std::io::error::Error as anyhow::kind::TraitKind>::anyhow_kind Unexecuted instantiation: <_ as anyhow::kind::TraitKind>::anyhow_kind |
85 | | } |
86 | | |
87 | | impl<E> TraitKind for E where E: Into<Error> {} |
88 | | |
89 | | impl Trait { |
90 | | #[cold] |
91 | 0 | pub fn new<E>(self, error: E) -> Error |
92 | 0 | where |
93 | 0 | E: Into<Error>, |
94 | | { |
95 | 0 | error.into() |
96 | 0 | } Unexecuted instantiation: <anyhow::kind::Trait>::new::<ztunnel::xds::Error> Unexecuted instantiation: <anyhow::kind::Trait>::new::<std::io::error::Error> Unexecuted instantiation: <anyhow::kind::Trait>::new::<_> |
97 | | } |
98 | | |
99 | | #[cfg(any(feature = "std", not(anyhow_no_core_error)))] |
100 | | pub struct Boxed; |
101 | | |
102 | | #[cfg(any(feature = "std", not(anyhow_no_core_error)))] |
103 | | #[doc(hidden)] |
104 | | pub trait BoxedKind: Sized { |
105 | | #[inline] |
106 | 0 | fn anyhow_kind(&self) -> Boxed { |
107 | 0 | Boxed |
108 | 0 | } |
109 | | } |
110 | | |
111 | | #[cfg(any(feature = "std", not(anyhow_no_core_error)))] |
112 | | impl BoxedKind for Box<dyn StdError + Send + Sync> {} |
113 | | |
114 | | #[cfg(any(feature = "std", not(anyhow_no_core_error)))] |
115 | | impl Boxed { |
116 | | #[cold] |
117 | 0 | pub fn new(self, error: Box<dyn StdError + Send + Sync>) -> Error { |
118 | 0 | let backtrace = backtrace_if_absent!(&*error); |
119 | 0 | Error::construct_from_boxed(error, backtrace) |
120 | 0 | } |
121 | | } |