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
//! Definitions used in derived implementations of [`core::convert`] traits.
#[cfg(feature = "try_from")]
pub use self::try_from::TryFromReprError;
#[cfg(feature = "try_into")]
pub use self::try_into::TryIntoError;
#[cfg(feature = "try_from")]
mod try_from {
use core::{error::Error, fmt};
/// Error returned by the derived [`TryFrom`] implementation on enums to
/// convert from their repr.
///
/// [`TryFrom`]: macro@crate::TryFrom
#[derive(Clone, Copy, Debug)]
pub struct TryFromReprError<T> {
/// Original input value which failed to convert via the derived
/// [`TryFrom`] implementation.
///
/// [`TryFrom`]: macro@crate::TryFrom
pub input: T,
}
impl<T> TryFromReprError<T> {
#[doc(hidden)]
#[must_use]
#[inline]
pub const fn new(input: T) -> Self {
Self { input }
}
}
// `T`, as a discriminant, should only be an integer type, and therefore be `Debug`.
impl<T: fmt::Debug> fmt::Display for TryFromReprError<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"`{:?}` does not correspond to a unit variant",
self.input
)
}
}
// `T` should only be an integer type and therefore be `Debug`.
impl<T: fmt::Debug> Error for TryFromReprError<T> {}
}
#[cfg(feature = "try_into")]
mod try_into {
use core::{error::Error, fmt};
/// Error returned by the derived [`TryInto`] implementation.
///
/// [`TryInto`]: macro@crate::TryInto
#[derive(Clone, Copy, Debug)]
pub struct TryIntoError<T> {
/// Original input value which failed to convert via the derived
/// [`TryInto`] implementation.
///
/// [`TryInto`]: macro@crate::TryInto
pub input: T,
variant_names: &'static str,
output_type: &'static str,
}
impl<T> TryIntoError<T> {
#[doc(hidden)]
#[must_use]
#[inline]
pub const fn new(
input: T,
variant_names: &'static str,
output_type: &'static str,
) -> Self {
Self {
input,
variant_names,
output_type,
}
}
}
impl<T> fmt::Display for TryIntoError<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"Only {} can be converted to {}",
self.variant_names, self.output_type,
)
}
}
impl<T: fmt::Debug> Error for TryIntoError<T> {}
}