19771986547

Committed 28 Nov 2025 07:03PM UTC coverage: 60.235% (-0.7%) from 60.902%

Build # 19771986547

Build Type

Pull #956

github

Committed by

web-flow

Commit Message

Merge 67a560773 into 628cd558c

Pull Request Pull Request #956: Add DynamicValue support for deserializing into facet_value::Value

Run Details

294 of 744 new or added lines in 19 files covered. (39.52%)

285 existing lines in 3 files now uncovered.

16705 of 27733 relevant lines covered (60.24%)

153.12 hits per line

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

56.06

/facet-reflect/src/partial/partial_api/maps.rs

use super::*;

////////////////////////////////////////////////////////////////////////////////////////////////////
// Maps
////////////////////////////////////////////////////////////////////////////////////////////////////
impl Partial<'_> {
    /// Begins a map initialization operation
    ///
    /// This initializes the map with default capacity and allows inserting key-value pairs
    /// It does _not_ push a new frame onto the stack.
    pub fn begin_map(&mut self) -> Result<&mut Self, ReflectError> {
        self.require_active()?;
        let frame = self.frames_mut().last_mut().unwrap();

        // Check tracker state before initializing
        match &frame.tracker {
            Tracker::Scalar if !frame.is_init => {
                // Good, will initialize below
            }
            Tracker::Scalar => {
                // is_init is true - already initialized (from a previous round), just update tracker
                if !matches!(frame.shape.def, Def::Map(_)) {
                    return Err(ReflectError::OperationFailed {
                        shape: frame.shape,
                        operation: "begin_map can only be called on Map types",
                    });
                }
                frame.tracker = Tracker::Map {
                    is_initialized: true,
                    insert_state: MapInsertState::Idle,
                };
                return Ok(self);
            }
            Tracker::Map { is_initialized, .. } => {
                if *is_initialized {
                    // Already initialized, nothing to do
                    return Ok(self);
                }
            }
            _ => {
                return Err(ReflectError::UnexpectedTracker {
                    message: "begin_map called but tracker isn't Scalar or Map",
                    current_tracker: frame.tracker.kind(),
                });
            }
        }

        // Check that we have a Map
        let map_def = match &frame.shape.def {
            Def::Map(map_def) => map_def,
            _ => {
                return Err(ReflectError::OperationFailed {
                    shape: frame.shape,
                    operation: "begin_map can only be called on Map types",
                });
            }
        };

        let init_fn = map_def.vtable.init_in_place_with_capacity_fn;

        // Initialize the map with default capacity (0)
        unsafe {
            init_fn(frame.data, 0);
        }

        // Update tracker to Map state
        frame.tracker = Tracker::Map {
            is_initialized: true,
            insert_state: MapInsertState::Idle,
        };

        Ok(self)
    }

    /// Pushes a frame for the map key. After that, `set()` should be called
    /// (or the key should be initialized somehow) and `end()` should be called
    /// to pop the frame.
    pub fn begin_key(&mut self) -> Result<&mut Self, ReflectError> {
        self.require_active()?;
        let frame = self.frames_mut().last_mut().unwrap();

        // Check that we have a Map in Idle state
        let map_def = match (&frame.shape.def, &frame.tracker) {
            (
                Def::Map(map_def),
                Tracker::Map {
                    is_initialized: true,
                    insert_state: MapInsertState::Idle,
                },
            ) => map_def,
            (
                Def::Map(_),
                Tracker::Map {
                    insert_state: MapInsertState::PushingKey { .. },
                    ..
                },
            ) => {
                return Err(ReflectError::OperationFailed {
                    shape: frame.shape,
                    operation: "already pushing a key, call end() first",
                });
            }
            (
                Def::Map(_),
                Tracker::Map {
                    insert_state: MapInsertState::PushingValue { .. },
                    ..
                },
            ) => {
                return Err(ReflectError::OperationFailed {
                    shape: frame.shape,
                    operation: "must complete current operation before begin_key()",
                });
            }
            _ => {
                return Err(ReflectError::OperationFailed {
                    shape: frame.shape,
                    operation: "must call begin_map() before begin_key()",
                });
            }
        };

        // Get the key shape
        let key_shape = map_def.k();

        // Allocate space for the key
        let key_layout = match key_shape.layout.sized_layout() {
            Ok(layout) => layout,
            Err(_) => {
                return Err(ReflectError::Unsized {
                    shape: key_shape,
                    operation: "begin_key allocating key",
                });
            }
        };
        let key_ptr_raw: *mut u8 = unsafe { ::alloc::alloc::alloc(key_layout) };

        let Some(key_ptr_raw) = NonNull::new(key_ptr_raw) else {
            return Err(ReflectError::OperationFailed {
                shape: frame.shape,
                operation: "failed to allocate memory for map key",
            });
        };

        let key_ptr = PtrUninit::new(key_ptr_raw);

        // Store the key pointer in the insert state
        match &mut frame.tracker {
            Tracker::Map { insert_state, .. } => {
                *insert_state = MapInsertState::PushingKey {
                    key_ptr,
                    key_initialized: false,
                };
            }
            _ => unreachable!(),
        }

        // Push a new frame for the key
        self.frames_mut().push(Frame::new(
            PtrUninit::new(key_ptr_raw),
            key_shape,
            FrameOwnership::ManagedElsewhere, // Ownership tracked in MapInsertState
        ));

        Ok(self)
    }

    /// Pushes a frame for the map value
    /// Must be called after the key has been set and popped
    pub fn begin_value(&mut self) -> Result<&mut Self, ReflectError> {
        self.require_active()?;
        let frame = self.frames_mut().last_mut().unwrap();

        // Check that we have a Map in PushingValue state with no value_ptr yet
        let (map_def, key_ptr) = match (&frame.shape.def, &frame.tracker) {
            (
                Def::Map(map_def),
                Tracker::Map {
                    insert_state:
                        MapInsertState::PushingValue {
                            value_ptr: None,
                            key_ptr,
                            ..
                        },
                    ..
                },
            ) => (map_def, *key_ptr),
            (
                Def::Map(_),
                Tracker::Map {
                    insert_state:
                        MapInsertState::PushingValue {
                            value_ptr: Some(_), ..
                        },
                    ..
                },
            ) => {
                return Err(ReflectError::OperationFailed {
                    shape: frame.shape,
                    operation: "already pushing a value, call end() first",
                });
            }
            _ => {
                return Err(ReflectError::OperationFailed {
                    shape: frame.shape,
                    operation: "must complete key before begin_value()",
                });
            }
        };

        // Get the value shape
        let value_shape = map_def.v();

        // Allocate space for the value
        let value_layout = match value_shape.layout.sized_layout() {
            Ok(layout) => layout,
            Err(_) => {
                return Err(ReflectError::Unsized {
                    shape: value_shape,
                    operation: "begin_value allocating value",
                });
            }
        };
        let value_ptr_raw: *mut u8 = unsafe { ::alloc::alloc::alloc(value_layout) };

        let Some(value_ptr_raw) = NonNull::new(value_ptr_raw) else {
            return Err(ReflectError::OperationFailed {
                shape: frame.shape,
                operation: "failed to allocate memory for map value",
            });
        };

        let value_ptr = PtrUninit::new(value_ptr_raw);

        // Store the value pointer in the insert state
        match &mut frame.tracker {
            Tracker::Map { insert_state, .. } => {
                *insert_state = MapInsertState::PushingValue {
                    key_ptr,
                    value_ptr: Some(value_ptr),
                    value_initialized: false,
                };
            }
            _ => unreachable!(),
        }

        // Push a new frame for the value
        self.frames_mut().push(Frame::new(
            value_ptr,
            value_shape,
            FrameOwnership::ManagedElsewhere, // Ownership tracked in MapInsertState
        ));

        Ok(self)
    }
}

1	use super::*;
2
3	////////////////////////////////////////////////////////////////////////////////////////////////////
4	// Maps
5	////////////////////////////////////////////////////////////////////////////////////////////////////
6	impl Partial<'_> {
7	/// Begins a map initialization operation
8	///
9	/// This initializes the map with default capacity and allows inserting key-value pairs
10	/// It does _not_ push a new frame onto the stack.
11	pub fn begin_map(&mut self) -> Result<&mut Self, ReflectError> {	73✔
12	self.require_active()?;	73✔
13	let frame = self.frames_mut().last_mut().unwrap();	73✔
14
15	// Check tracker state before initializing
16	match &frame.tracker {	66✔
17	Tracker::Scalar if !frame.is_init => {	66✔
18	// Good, will initialize below	66✔
19	}	66✔
20	Tracker::Scalar => {
21	// is_init is true - already initialized (from a previous round), just update tracker
22	if !matches!(frame.shape.def, Def::Map(_)) {	×
23	return Err(ReflectError::OperationFailed {	×
24	shape: frame.shape,	×
25	operation: "begin_map can only be called on Map types",	×
26	});	×
27	}	×
28	frame.tracker = Tracker::Map {	×
29	is_initialized: true,	×
30	insert_state: MapInsertState::Idle,	×
31	};	×
32	return Ok(self);	×
33	}
34	Tracker::Map { is_initialized, .. } => {	7✔
35	if *is_initialized {	7✔
36	// Already initialized, nothing to do
37	return Ok(self);	7✔
38	}	×
39	}
40	_ => {
41	return Err(ReflectError::UnexpectedTracker {	×
NEW 42	message: "begin_map called but tracker isn't Scalar or Map",	×
43	current_tracker: frame.tracker.kind(),	×
44	});	×
45	}
46	}
47
48	// Check that we have a Map
49	let map_def = match &frame.shape.def {	66✔
50	Def::Map(map_def) => map_def,	66✔
51	_ => {
52	return Err(ReflectError::OperationFailed {	×
53	shape: frame.shape,	×
54	operation: "begin_map can only be called on Map types",	×
55	});	×
56	}
57	};
58
59	let init_fn = map_def.vtable.init_in_place_with_capacity_fn;	66✔
60
61	// Initialize the map with default capacity (0)
62	unsafe {	66✔
63	init_fn(frame.data, 0);	66✔
64	}	66✔
65
66	// Update tracker to Map state
67	frame.tracker = Tracker::Map {	66✔
68	is_initialized: true,	66✔
69	insert_state: MapInsertState::Idle,	66✔
70	};	66✔
71
72	Ok(self)	66✔
73	}	73✔
74
75	/// Pushes a frame for the map key. After that, `set()` should be called
76	/// (or the key should be initialized somehow) and `end()` should be called
77	/// to pop the frame.
78	pub fn begin_key(&mut self) -> Result<&mut Self, ReflectError> {	96✔
79	self.require_active()?;	96✔
80	let frame = self.frames_mut().last_mut().unwrap();	96✔
81
82	// Check that we have a Map in Idle state
83	let map_def = match (&frame.shape.def, &frame.tracker) {	96✔
84	(
85	Def::Map(map_def),	96✔
86	Tracker::Map {
87	is_initialized: true,
88	insert_state: MapInsertState::Idle,
89	},
90	) => map_def,	96✔
91	(
92	Def::Map(_),
93	Tracker::Map {
94	insert_state: MapInsertState::PushingKey { .. },
95	..
96	},
97	) => {
98	return Err(ReflectError::OperationFailed {	×
99	shape: frame.shape,	×
100	operation: "already pushing a key, call end() first",	×
101	});	×
102	}
103	(
104	Def::Map(_),
105	Tracker::Map {
106	insert_state: MapInsertState::PushingValue { .. },
107	..
108	},
109	) => {
110	return Err(ReflectError::OperationFailed {	×
111	shape: frame.shape,	×
112	operation: "must complete current operation before begin_key()",	×
113	});	×
114	}
115	_ => {
116	return Err(ReflectError::OperationFailed {	×
117	shape: frame.shape,	×
118	operation: "must call begin_map() before begin_key()",	×
119	});	×
120	}
121	};
122
123	// Get the key shape
124	let key_shape = map_def.k();	96✔
125
126	// Allocate space for the key
127	let key_layout = match key_shape.layout.sized_layout() {	96✔
128	Ok(layout) => layout,	96✔
129	Err(_) => {
130	return Err(ReflectError::Unsized {	×
131	shape: key_shape,	×
132	operation: "begin_key allocating key",	×
133	});	×
134	}
135	};
136	let key_ptr_raw: *mut u8 = unsafe { ::alloc::alloc::alloc(key_layout) };	96✔
137
138	let Some(key_ptr_raw) = NonNull::new(key_ptr_raw) else {	96✔
139	return Err(ReflectError::OperationFailed {	×
140	shape: frame.shape,	×
141	operation: "failed to allocate memory for map key",	×
142	});	×
143	};
144
145	let key_ptr = PtrUninit::new(key_ptr_raw);	96✔
146
147	// Store the key pointer in the insert state
148	match &mut frame.tracker {	96✔
149	Tracker::Map { insert_state, .. } => {	96✔
150	*insert_state = MapInsertState::PushingKey {	96✔
151	key_ptr,	96✔
152	key_initialized: false,	96✔
153	};	96✔
154	}	96✔
155	_ => unreachable!(),	×
156	}
157
158	// Push a new frame for the key
159	self.frames_mut().push(Frame::new(	96✔
160	PtrUninit::new(key_ptr_raw),	96✔
161	key_shape,	96✔
162	FrameOwnership::ManagedElsewhere, // Ownership tracked in MapInsertState	96✔
163	));
164
165	Ok(self)	96✔
166	}	96✔
167
168	/// Pushes a frame for the map value
169	/// Must be called after the key has been set and popped
170	pub fn begin_value(&mut self) -> Result<&mut Self, ReflectError> {	92✔
171	self.require_active()?;	92✔
172	let frame = self.frames_mut().last_mut().unwrap();	92✔
173
174	// Check that we have a Map in PushingValue state with no value_ptr yet
175	let (map_def, key_ptr) = match (&frame.shape.def, &frame.tracker) {	92✔
176	(
177	Def::Map(map_def),	92✔
178	Tracker::Map {
179	insert_state:
180	MapInsertState::PushingValue {
181	value_ptr: None,
182	key_ptr,	92✔
183	..
184	},
185	..
186	},
187	) => (map_def, *key_ptr),	92✔
188	(
189	Def::Map(_),
190	Tracker::Map {
191	insert_state:
192	MapInsertState::PushingValue {
193	value_ptr: Some(_), ..
194	},
195	..
196	},
197	) => {
198	return Err(ReflectError::OperationFailed {	×
199	shape: frame.shape,	×
200	operation: "already pushing a value, call end() first",	×
201	});	×
202	}
203	_ => {
204	return Err(ReflectError::OperationFailed {	×
205	shape: frame.shape,	×
206	operation: "must complete key before begin_value()",	×
207	});	×
208	}
209	};
210
211	// Get the value shape
212	let value_shape = map_def.v();	92✔
213
214	// Allocate space for the value
215	let value_layout = match value_shape.layout.sized_layout() {	92✔
216	Ok(layout) => layout,	92✔
217	Err(_) => {
218	return Err(ReflectError::Unsized {	×
219	shape: value_shape,	×
220	operation: "begin_value allocating value",	×
221	});	×
222	}
223	};
224	let value_ptr_raw: *mut u8 = unsafe { ::alloc::alloc::alloc(value_layout) };	92✔
225
226	let Some(value_ptr_raw) = NonNull::new(value_ptr_raw) else {	92✔
227	return Err(ReflectError::OperationFailed {	×
228	shape: frame.shape,	×
229	operation: "failed to allocate memory for map value",	×
230	});	×
231	};
232
233	let value_ptr = PtrUninit::new(value_ptr_raw);	92✔
234
235	// Store the value pointer in the insert state
236	match &mut frame.tracker {	92✔
237	Tracker::Map { insert_state, .. } => {	92✔
238	*insert_state = MapInsertState::PushingValue {	92✔
239	key_ptr,	92✔
240	value_ptr: Some(value_ptr),	92✔
241	value_initialized: false,	92✔
242	};	92✔
243	}	92✔
244	_ => unreachable!(),	×
245	}
246
247	// Push a new frame for the value
248	self.frames_mut().push(Frame::new(	92✔
249	value_ptr,	92✔
250	value_shape,	92✔
251	FrameOwnership::ManagedElsewhere, // Ownership tracked in MapInsertState	92✔
252	));
253
254	Ok(self)	92✔
255	}	92✔
256	}

facet-rs / facet / 19771986547

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