15825042488

Committed 23 Jun 2025 01:03PM UTC coverage: 61.402% (-0.09%) from 61.492%

Build # 15825042488

Build Type

Pull #813

github

Committed by

web-flow

Commit Message

Merge 28e79deda into 0648bb765

Pull Request Pull Request #813: Attempt to support `Arc<[u8]>`

Run Details

84 of 170 new or added lines in 4 files covered. (49.41%)

3 existing lines in 1 file now uncovered.

10676 of 17387 relevant lines covered (61.4%)

155.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

32.22

/facet-reflect/src/error.rs

use facet_core::{Characteristic, EnumType, FieldError, Shape, TryFromError};
use owo_colors::OwoColorize;

/// Errors that can occur when reflecting on types.
#[derive(Clone)]
pub enum ReflectError<'shape> {
    /// Tried to set an enum to a variant that does not exist
    NoSuchVariant {
        /// The enum definition containing all known variants.
        enum_type: EnumType<'shape>,
    },

    /// Tried to get the wrong shape out of a value — e.g. we were manipulating
    /// a `String`, but `.get()` was called with a `u64` or something.
    WrongShape {
        /// The expected shape of the value.
        expected: &'shape Shape<'shape>,
        /// The actual shape of the value.
        actual: &'shape Shape<'shape>,
    },

    /// Attempted to perform an operation that expected a struct or something
    WasNotA {
        /// The name of the expected type.
        expected: &'shape str,

        /// The type we got instead
        actual: &'shape Shape<'shape>,
    },

    /// A field was not initialized during build
    UninitializedField {
        /// The shape containing the field
        shape: &'shape Shape<'shape>,
        /// The name of the field that wasn't initialized
        field_name: &'shape str,
    },

    /// A field in an enum variant was not initialized during build
    UninitializedEnumField {
        /// The enum shape
        shape: &'shape Shape<'shape>,
        /// The name of the field that wasn't initialized
        field_name: &'shape str,
        /// The name of the variant containing the field
        variant_name: &'shape str,
    },

    /// A scalar value was not initialized during build
    UninitializedValue {
        /// The scalar shape
        shape: &'shape Shape<'shape>,
    },

    /// An invariant of the reflection system was violated.
    InvariantViolation {
        /// The invariant that was violated.
        invariant: &'shape str,
    },

    /// Attempted to set a value to its default, but the value doesn't implement `Default`.
    MissingCharacteristic {
        /// The shape of the value that doesn't implement `Default`.
        shape: &'shape Shape<'shape>,
        /// The characteristic that is missing.
        characteristic: Characteristic,
    },

    /// An operation failed for a given shape
    OperationFailed {
        /// The shape of the value for which the operation failed.
        shape: &'shape Shape<'shape>,
        /// The name of the operation that failed.
        operation: &'shape str,
    },

    /// An error occurred when attempting to access or modify a field.
    FieldError {
        /// The shape of the value containing the field.
        shape: &'shape Shape<'shape>,
        /// The specific error that occurred with the field.
        field_error: FieldError,
    },

    /// Indicates that we try to access a field on an `Arc<T>`, for example, and the field might exist
    /// on the T, but you need to do begin_smart_ptr first when using the WIP API.
    MissingPushPointee {
        /// The smart pointer (`Arc<T>`, `Box<T>` etc.) shape on which field was caleld
        shape: &'shape Shape<'shape>,
    },

    /// An unknown error occurred.
    Unknown,

    /// An error occured while putting
    TryFromError {
        /// The shape of the value being converted from.
        src_shape: &'shape Shape<'shape>,

        /// The shape of the value being converted to.
        dst_shape: &'shape Shape<'shape>,

        /// The inner error
        inner: TryFromError<'shape>,
    },

    /// A shape has a `default` attribute, but no implementation of the `Default` trait.
    DefaultAttrButNoDefaultImpl {
        /// The shape of the value that has a `default` attribute but no default implementation.
        shape: &'shape Shape<'shape>,
    },

    /// The type is unsized
    Unsized {
        /// The shape for the type that is unsized
        shape: &'shape Shape<'shape>,
        /// The operation we were trying to perform
        operation: &'static str,
    },

    /// Array not fully initialized during build
    ArrayNotFullyInitialized {
        /// The shape of the array
        shape: &'shape Shape<'shape>,
        /// The number of elements pushed
        pushed_count: usize,
        /// The expected array size
        expected_size: usize,
    },

    /// Array index out of bounds
    ArrayIndexOutOfBounds {
        /// The shape of the array
        shape: &'shape Shape<'shape>,
        /// The index that was out of bounds
        index: usize,
        /// The array size
        size: usize,
    },

    /// Invalid operation for the current state
    InvalidOperation {
        /// The operation that was attempted
        operation: &'static str,
        /// The reason why it failed
        reason: &'static str,
    },

    /// No active frame in Partial
    NoActiveFrame,
}

impl core::fmt::Display for ReflectError<'_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            ReflectError::NoSuchVariant { enum_type } => {
                write!(f, "No such variant in enum. Known variants: ")?;
                for v in enum_type.variants {
                    write!(f, ", {}", v.name.cyan())?;
                }
                write!(f, ", that's it.")
            }
            ReflectError::WrongShape { expected, actual } => {
                write!(
                    f,
                    "Wrong shape: expected {}, but got {}",
                    expected.green(),
                    actual.red()
                )
            }
            ReflectError::WasNotA { expected, actual } => {
                write!(
                    f,
                    "Wrong shape: expected {}, but got {}",
                    expected.green(),
                    actual.red()
                )
            }
            ReflectError::UninitializedField { shape, field_name } => {
                write!(f, "Field '{shape}::{field_name}' was not initialized")
            }
            ReflectError::UninitializedEnumField {
                shape,
                field_name,
                variant_name,
            } => {
                write!(
                    f,
                    "Field '{}::{}' in variant '{}' was not initialized",
                    shape.blue(),
                    field_name.yellow(),
                    variant_name.red()
                )
            }
            ReflectError::UninitializedValue { shape } => {
                write!(f, "Value '{}' was not initialized", shape.blue())
            }
            ReflectError::InvariantViolation { invariant } => {
                write!(f, "Invariant violation: {}", invariant.red())
            }
            ReflectError::MissingCharacteristic {
                shape,
                characteristic,
            } => write!(
                f,
                "{shape} does not implement characteristic {characteristic:?}",
            ),
            ReflectError::OperationFailed { shape, operation } => {
                write!(
                    f,
                    "Operation failed on shape {}: {}",
                    shape.blue(),
                    operation
                )
            }
            ReflectError::FieldError { shape, field_error } => {
                write!(f, "Field error for shape {}: {}", shape.red(), field_error)
            }
            ReflectError::MissingPushPointee { shape } => {
                write!(
                    f,
                    "Tried to access a field on smart pointer '{}', but you need to call {} first to work with the value it points to (and pop it with {} later)",
                    shape.blue(),
                    ".begin_smart_ptr()".yellow(),
                    ".pop()".yellow()
                )
            }
            ReflectError::Unknown => write!(f, "Unknown error"),
            ReflectError::TryFromError {
                src_shape,
                dst_shape,
                inner,
            } => {
                write!(
                    f,
                    "While trying to put {} into a {}: {}",
                    src_shape.green(),
                    dst_shape.blue(),
                    inner.red()
                )
            }
            ReflectError::DefaultAttrButNoDefaultImpl { shape } => write!(
                f,
                "Shape '{}' has a `default` attribute but no default implementation",
                shape.red()
            ),
            ReflectError::Unsized { shape, operation } => write!(
                f,
                "Shape '{}' is unsized, can't perform operation {}",
                shape.red(),
                operation
            ),
            ReflectError::ArrayNotFullyInitialized {
                shape,
                pushed_count,
                expected_size,
            } => {
                write!(
                    f,
                    "Array '{}' not fully initialized: expected {} elements, but got {}",
                    shape.blue(),
                    expected_size,
                    pushed_count
                )
            }
            ReflectError::ArrayIndexOutOfBounds { shape, index, size } => {
                write!(
                    f,
                    "Array index {} out of bounds for '{}' (array length is {})",
                    index,
                    shape.blue(),
                    size
                )
            }
            ReflectError::InvalidOperation { operation, reason } => {
                write!(f, "Invalid operation '{}': {}", operation.yellow(), reason)
            }
            ReflectError::NoActiveFrame => {
                write!(f, "No active frame in Partial")
            }
        }
    }
}

impl core::fmt::Debug for ReflectError<'_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        // Use Display implementation for more readable output
        write!(f, "ReflectError({self})")
    }
}

impl core::error::Error for ReflectError<'_> {}

1	use facet_core::{Characteristic, EnumType, FieldError, Shape, TryFromError};
2	use owo_colors::OwoColorize;
3
4	/// Errors that can occur when reflecting on types.
5	#[derive(Clone)]
6	pub enum ReflectError<'shape> {
7	/// Tried to set an enum to a variant that does not exist
8	NoSuchVariant {
9	/// The enum definition containing all known variants.
10	enum_type: EnumType<'shape>,
11	},
12
13	/// Tried to get the wrong shape out of a value — e.g. we were manipulating
14	/// a `String`, but `.get()` was called with a `u64` or something.
15	WrongShape {
16	/// The expected shape of the value.
17	expected: &'shape Shape<'shape>,
18	/// The actual shape of the value.
19	actual: &'shape Shape<'shape>,
20	},
21
22	/// Attempted to perform an operation that expected a struct or something
23	WasNotA {
24	/// The name of the expected type.
25	expected: &'shape str,
26
27	/// The type we got instead
28	actual: &'shape Shape<'shape>,
29	},
30
31	/// A field was not initialized during build
32	UninitializedField {
33	/// The shape containing the field
34	shape: &'shape Shape<'shape>,
35	/// The name of the field that wasn't initialized
36	field_name: &'shape str,
37	},
38
39	/// A field in an enum variant was not initialized during build
40	UninitializedEnumField {
41	/// The enum shape
42	shape: &'shape Shape<'shape>,
43	/// The name of the field that wasn't initialized
44	field_name: &'shape str,
45	/// The name of the variant containing the field
46	variant_name: &'shape str,
47	},
48
49	/// A scalar value was not initialized during build
50	UninitializedValue {
51	/// The scalar shape
52	shape: &'shape Shape<'shape>,
53	},
54
55	/// An invariant of the reflection system was violated.
56	InvariantViolation {
57	/// The invariant that was violated.
58	invariant: &'shape str,
59	},
60
61	/// Attempted to set a value to its default, but the value doesn't implement `Default`.
62	MissingCharacteristic {
63	/// The shape of the value that doesn't implement `Default`.
64	shape: &'shape Shape<'shape>,
65	/// The characteristic that is missing.
66	characteristic: Characteristic,
67	},
68
69	/// An operation failed for a given shape
70	OperationFailed {
71	/// The shape of the value for which the operation failed.
72	shape: &'shape Shape<'shape>,
73	/// The name of the operation that failed.
74	operation: &'shape str,
75	},
76
77	/// An error occurred when attempting to access or modify a field.
78	FieldError {
79	/// The shape of the value containing the field.
80	shape: &'shape Shape<'shape>,
81	/// The specific error that occurred with the field.
82	field_error: FieldError,
83	},
84
85	/// Indicates that we try to access a field on an `Arc<T>`, for example, and the field might exist
86	/// on the T, but you need to do begin_smart_ptr first when using the WIP API.
87	MissingPushPointee {
88	/// The smart pointer (`Arc<T>`, `Box<T>` etc.) shape on which field was caleld
89	shape: &'shape Shape<'shape>,
90	},
91
92	/// An unknown error occurred.
93	Unknown,
94
95	/// An error occured while putting
96	TryFromError {
97	/// The shape of the value being converted from.
98	src_shape: &'shape Shape<'shape>,
99
100	/// The shape of the value being converted to.
101	dst_shape: &'shape Shape<'shape>,
102
103	/// The inner error
104	inner: TryFromError<'shape>,
105	},
106
107	/// A shape has a `default` attribute, but no implementation of the `Default` trait.
108	DefaultAttrButNoDefaultImpl {
109	/// The shape of the value that has a `default` attribute but no default implementation.
110	shape: &'shape Shape<'shape>,
111	},
112
113	/// The type is unsized
114	Unsized {
115	/// The shape for the type that is unsized
116	shape: &'shape Shape<'shape>,
117	/// The operation we were trying to perform
118	operation: &'static str,
119	},
120
121	/// Array not fully initialized during build
122	ArrayNotFullyInitialized {
123	/// The shape of the array
124	shape: &'shape Shape<'shape>,
125	/// The number of elements pushed
126	pushed_count: usize,
127	/// The expected array size
128	expected_size: usize,
129	},
130
131	/// Array index out of bounds
132	ArrayIndexOutOfBounds {
133	/// The shape of the array
134	shape: &'shape Shape<'shape>,
135	/// The index that was out of bounds
136	index: usize,
137	/// The array size
138	size: usize,
139	},
140
141	/// Invalid operation for the current state
142	InvalidOperation {
143	/// The operation that was attempted
144	operation: &'static str,
145	/// The reason why it failed
146	reason: &'static str,
147	},
148
149	/// No active frame in Partial
150	NoActiveFrame,
151	}
152
153	impl core::fmt::Display for ReflectError<'_> {
154	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {	32✔
155	match self {	32✔
156	ReflectError::NoSuchVariant { enum_type } => {	×
157	write!(f, "No such variant in enum. Known variants: ")?;	×
158	for v in enum_type.variants {	×
159	write!(f, ", {}", v.name.cyan())?;	×
160	}
161	write!(f, ", that's it.")	×
162	}
163	ReflectError::WrongShape { expected, actual } => {	4✔
164	write!(	4✔
165	f,	4✔
166	"Wrong shape: expected {}, but got {}",	4✔
167	expected.green(),	4✔
168	actual.red()	4✔
169	)
170	}
171	ReflectError::WasNotA { expected, actual } => {	×
172	write!(	×
173	f,	×
174	"Wrong shape: expected {}, but got {}",	×
175	expected.green(),	×
176	actual.red()	×
177	)
178	}
179	ReflectError::UninitializedField { shape, field_name } => {	10✔
180	write!(f, "Field '{shape}::{field_name}' was not initialized")	10✔
181	}
182	ReflectError::UninitializedEnumField {
183	shape,	×
184	field_name,	×
185	variant_name,	×
186	} => {
187	write!(	×
188	f,	×
189	"Field '{}::{}' in variant '{}' was not initialized",	×
190	shape.blue(),	×
191	field_name.yellow(),	×
192	variant_name.red()	×
193	)
194	}
195	ReflectError::UninitializedValue { shape } => {	7✔
196	write!(f, "Value '{}' was not initialized", shape.blue())	7✔
197	}
198	ReflectError::InvariantViolation { invariant } => {	2✔
199	write!(f, "Invariant violation: {}", invariant.red())	2✔
200	}
201	ReflectError::MissingCharacteristic {
202	shape,	×
203	characteristic,	×
204	} => write!(	×
205	f,	×
206	"{shape} does not implement characteristic {characteristic:?}",	×
207	),
208	ReflectError::OperationFailed { shape, operation } => {	8✔
209	write!(	8✔
210	f,	8✔
211	"Operation failed on shape {}: {}",	8✔
212	shape.blue(),	8✔
213	operation
214	)
215	}
216	ReflectError::FieldError { shape, field_error } => {	×
217	write!(f, "Field error for shape {}: {}", shape.red(), field_error)	×
218	}
219	ReflectError::MissingPushPointee { shape } => {	×
220	write!(	×
221	f,	×
222	"Tried to access a field on smart pointer '{}', but you need to call {} first to work with the value it points to (and pop it with {} later)",	×
223	shape.blue(),	×
224	".begin_smart_ptr()".yellow(),	×
225	".pop()".yellow()	×
226	)
227	}
228	ReflectError::Unknown => write!(f, "Unknown error"),	×
229	ReflectError::TryFromError {
230	src_shape,	1✔
231	dst_shape,	1✔
232	inner,	1✔
233	} => {
234	write!(	1✔
235	f,	1✔
236	"While trying to put {} into a {}: {}",	1✔
237	src_shape.green(),	1✔
238	dst_shape.blue(),	1✔
239	inner.red()	1✔
240	)
241	}
242	ReflectError::DefaultAttrButNoDefaultImpl { shape } => write!(	×
243	f,	×
244	"Shape '{}' has a `default` attribute but no default implementation",	×
245	shape.red()	×
246	),
NEW 247	ReflectError::Unsized { shape, operation } => write!(	×
NEW 248	f,	×
NEW 249	"Shape '{}' is unsized, can't perform operation {}",	×
NEW 250	shape.red(),	×
251	operation
252	),
253	ReflectError::ArrayNotFullyInitialized {
254	shape,	×
255	pushed_count,	×
256	expected_size,	×
257	} => {
258	write!(	×
259	f,	×
260	"Array '{}' not fully initialized: expected {} elements, but got {}",	×
261	shape.blue(),	×
262	expected_size,
263	pushed_count
264	)
265	}
266	ReflectError::ArrayIndexOutOfBounds { shape, index, size } => {	×
267	write!(	×
268	f,	×
269	"Array index {} out of bounds for '{}' (array length is {})",	×
270	index,
271	shape.blue(),	×
272	size
273	)
274	}
275	ReflectError::InvalidOperation { operation, reason } => {	×
276	write!(f, "Invalid operation '{}': {}", operation.yellow(), reason)	×
277	}
278	ReflectError::NoActiveFrame => {
279	write!(f, "No active frame in Partial")	×
280	}
281	}
282	}	32✔
283	}
284
285	impl core::fmt::Debug for ReflectError<'_> {
286	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {	×
287	// Use Display implementation for more readable output
288	write!(f, "ReflectError({self})")	×
289	}	×
290	}
291
292	impl core::error::Error for ReflectError<'_> {}

facet-rs / facet / 15825042488

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous