15364550646

Committed 31 May 2025 02:22PM UTC coverage: 58.373% (-0.03%) from 58.402%

Build # 15364550646

Build Type

Pull #709

github

Committed by

web-flow

Commit Message

Merge 57292f2ef into 3a8f3a3bb

Pull Request Pull Request #709: Try an iterative interface, see what it does to perf

Run Details

19 of 51 new or added lines in 8 files covered. (37.25%)

2 existing lines in 2 files now uncovered.

10185 of 17448 relevant lines covered (58.37%)

128.06 hits per line

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

51.74

/facet-serialize/src/debug_serializer.rs

use core::borrow::Borrow;

use crate::Serializer;

use alloc::vec::Vec;

struct DebugSerializer<W> {
    writer: W,
    need_comma: Vec<bool>,
}

#[derive(Debug)]
enum DebugError {
    Fmt(core::fmt::Error),
}

impl core::fmt::Display for DebugError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        core::fmt::Debug::fmt(self, f)
    }
}

impl core::error::Error for DebugError {}

impl From<core::fmt::Error> for DebugError {
    fn from(err: core::fmt::Error) -> Self {
        DebugError::Fmt(err)
    }
}

impl<'shape, W> Serializer<'shape> for DebugSerializer<W>
where
    W: core::fmt::Write,
{
    type Error = DebugError;

    fn serialize_u8(&mut self, value: u8) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_u16(&mut self, value: u16) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_u32(&mut self, value: u32) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_u64(&mut self, value: u64) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_u128(&mut self, value: u128) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_usize(&mut self, value: usize) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_i8(&mut self, value: i8) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_i16(&mut self, value: i16) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_i32(&mut self, value: i32) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_i64(&mut self, value: i64) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_i128(&mut self, value: i128) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_isize(&mut self, value: isize) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_f32(&mut self, value: f32) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_f64(&mut self, value: f64) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_bool(&mut self, value: bool) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{}", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_char(&mut self, value: char) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "\"{}\"", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "\"{}\"", value)?;
        self.set_comma();
        Ok(())
    }

    fn serialize_bytes(
        &mut self,
        _len: usize,
        value: impl IntoIterator<Item = impl Borrow<u8>>,
    ) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "[")?;

        self.need_comma.push(false);
        for byte in value.into_iter() {
            self.write_comma()?;
            write!(self.writer, "{}", byte.borrow())?;
            self.set_comma();
        }
        self.need_comma.pop();

        write!(self.writer, "]")?;
        self.set_comma();
        Ok(())
    }

    fn serialize_none(&mut self) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "null")?;
        self.set_comma();
        Ok(())
    }

    fn serialize_unit(&mut self) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "null")?;
        self.set_comma();
        Ok(())
    }

    fn serialize_unit_variant(
        &mut self,
        _variant_index: usize,
        variant_name: &str,
    ) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "\"{}\"", variant_name)?;
        self.set_comma();
        Ok(())
    }

    fn start_object(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{{")?;
        self.need_comma.push(false);
        Ok(())
    }

    fn end_object(&mut self) -> Result<(), Self::Error> {
        self.need_comma.pop();
        write!(self.writer, "}}")?;
        self.set_comma();
        Ok(())
    }

    fn start_array(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "[")?;
        self.need_comma.push(false);
        Ok(())
    }

    fn end_array(&mut self) -> Result<(), Self::Error> {
        self.need_comma.pop();
        write!(self.writer, "]")?;
        self.set_comma();
        Ok(())
    }

    fn start_map(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "{{")?;
        self.need_comma.push(false);
        Ok(())
    }

    fn end_map(&mut self) -> Result<(), Self::Error> {
        self.need_comma.pop();
        write!(self.writer, "}}")?;
        self.set_comma();
        Ok(())
    }

    fn serialize_field_name(&mut self, name: &str) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "\"{}\":", name)?;
        if let Some(need_comma) = self.need_comma.last_mut() {
            *need_comma = false;
        }
        Ok(())
    }
}

impl<W> DebugSerializer<W>
where
    W: core::fmt::Write,
{
    fn write_comma(&mut self) -> Result<(), DebugError> {
        if let Some(&true) = self.need_comma.last() {
            write!(self.writer, ", ")?;
        }
        Ok(())
    }

    fn set_comma(&mut self) {
        if let Some(need_comma) = self.need_comma.last_mut() {
            *need_comma = true;
        }
    }
}

#[cfg(test)]
mod tests {
    use facet::Facet;
    use facet_reflect::Peek;

    use crate::serialize_iterative;

    use super::DebugSerializer;

    #[derive(Facet)]
    struct FooBarBaz {
        foo: u32,
        bar: String,
        baz: bool,
    }

    #[test]
    fn test_serialize_debug() -> eyre::Result<()> {
        facet_testhelpers::setup();

        let val = FooBarBaz {
            foo: 42,
            bar: "Hello".to_string(),
            baz: true,
        };
        let peek = Peek::new(&val);

        let mut s = String::new();
        let mut serializer = DebugSerializer {
            writer: &mut s,
            need_comma: vec![false],
        };
        serialize_iterative(peek, &mut serializer)?;
        #[cfg(not(miri))]
        insta::assert_snapshot!(s);

        Ok(())
    }

    #[derive(Facet)]
    struct FooBarBazContainer {
        foo_bar_baz: FooBarBaz,
        other_things: Vec<SomeEnum>,
        maybe_value: Option<u32>,
        definitely_none: Option<String>,
    }

    #[derive(Facet)]
    #[repr(u8)]
    #[allow(dead_code)]
    enum SomeEnum {
        Variant1,
        Variant2(u32, String),
        Variant3 { field1: u32, field2: String },
    }

    #[test]
    fn test_serialize_debug_container() {
        facet_testhelpers::setup();

        let val = FooBarBazContainer {
            foo_bar_baz: FooBarBaz {
                foo: 42,
                bar: "Hello".to_string(),
                baz: true,
            },
            other_things: vec![
                SomeEnum::Variant1,
                SomeEnum::Variant2(123, "TupleVariant".to_string()),
                SomeEnum::Variant3 {
                    field1: 456,
                    field2: "StructVariant".to_string(),
                },
            ],
            maybe_value: Some(42),
            definitely_none: None,
        };
        let peek = Peek::new(&val);

        let mut s = String::new();
        let mut serializer = DebugSerializer {
            writer: &mut s,
            need_comma: vec![false],
        };
        serialize_iterative(peek, &mut serializer).unwrap();
        #[cfg(not(miri))]
        insta::assert_snapshot!(s);
    }

    #[derive(Facet)]
    #[facet(transparent)]
    #[repr(transparent)]
    struct Wrapper(String);

    #[test]
    fn test_serialize_transparent() {
        facet_testhelpers::setup();

        let val = Wrapper("TransparentValue".to_string());
        let peek = Peek::new(&val);

        let mut s = String::new();
        let mut serializer = DebugSerializer {
            writer: &mut s,
            need_comma: vec![false],
        };
        serialize_iterative(peek, &mut serializer).unwrap();
        #[cfg(not(miri))]
        insta::assert_snapshot!(s);
    }
}

1	use core::borrow::Borrow;
2
3	use crate::Serializer;
4
5	use alloc::vec::Vec;
6
7	struct DebugSerializer<W> {
8	writer: W,
9	need_comma: Vec<bool>,
10	}
11
12	#[derive(Debug)]
13	enum DebugError {
14	Fmt(core::fmt::Error),
15	}
16
17	impl core::fmt::Display for DebugError {
18	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {	×
19	core::fmt::Debug::fmt(self, f)	×
20	}	×
21	}
22
23	impl core::error::Error for DebugError {}
24
25	impl From<core::fmt::Error> for DebugError {
26	fn from(err: core::fmt::Error) -> Self {	×
27	DebugError::Fmt(err)	×
28	}	×
29	}
30
31	impl<'shape, W> Serializer<'shape> for DebugSerializer<W>
32	where
33	W: core::fmt::Write,
34	{
35	type Error = DebugError;
36
37	fn serialize_u8(&mut self, value: u8) -> Result<(), Self::Error> {	×
38	self.write_comma()?;	×
39	write!(self.writer, "{}", value)?;	×
40	self.set_comma();	×
41	Ok(())	×
42	}	×
43
44	fn serialize_u16(&mut self, value: u16) -> Result<(), Self::Error> {	×
45	self.write_comma()?;	×
46	write!(self.writer, "{}", value)?;	×
47	self.set_comma();	×
48	Ok(())	×
49	}	×
50
51	fn serialize_u32(&mut self, value: u32) -> Result<(), Self::Error> {	5✔
52	self.write_comma()?;	5✔
53	write!(self.writer, "{}", value)?;	5✔
54	self.set_comma();	5✔
55	Ok(())	5✔
56	}	5✔
57
58	fn serialize_u64(&mut self, value: u64) -> Result<(), Self::Error> {	×
59	self.write_comma()?;	×
60	write!(self.writer, "{}", value)?;	×
61	self.set_comma();	×
62	Ok(())	×
63	}	×
64
65	fn serialize_u128(&mut self, value: u128) -> Result<(), Self::Error> {	×
66	self.write_comma()?;	×
67	write!(self.writer, "{}", value)?;	×
68	self.set_comma();	×
69	Ok(())	×
70	}	×
71
72	fn serialize_usize(&mut self, value: usize) -> Result<(), Self::Error> {	×
73	self.write_comma()?;	×
74	write!(self.writer, "{}", value)?;	×
75	self.set_comma();	×
76	Ok(())	×
77	}	×
78
79	fn serialize_i8(&mut self, value: i8) -> Result<(), Self::Error> {	×
80	self.write_comma()?;	×
81	write!(self.writer, "{}", value)?;	×
82	self.set_comma();	×
83	Ok(())	×
84	}	×
85
86	fn serialize_i16(&mut self, value: i16) -> Result<(), Self::Error> {	×
87	self.write_comma()?;	×
88	write!(self.writer, "{}", value)?;	×
89	self.set_comma();	×
90	Ok(())	×
91	}	×
92
93	fn serialize_i32(&mut self, value: i32) -> Result<(), Self::Error> {	×
94	self.write_comma()?;	×
95	write!(self.writer, "{}", value)?;	×
96	self.set_comma();	×
97	Ok(())	×
98	}	×
99
100	fn serialize_i64(&mut self, value: i64) -> Result<(), Self::Error> {	×
101	self.write_comma()?;	×
102	write!(self.writer, "{}", value)?;	×
103	self.set_comma();	×
104	Ok(())	×
105	}	×
106
107	fn serialize_i128(&mut self, value: i128) -> Result<(), Self::Error> {	×
108	self.write_comma()?;	×
109	write!(self.writer, "{}", value)?;	×
110	self.set_comma();	×
111	Ok(())	×
112	}	×
113
114	fn serialize_isize(&mut self, value: isize) -> Result<(), Self::Error> {	×
115	self.write_comma()?;	×
116	write!(self.writer, "{}", value)?;	×
117	self.set_comma();	×
118	Ok(())	×
119	}	×
120
121	fn serialize_f32(&mut self, value: f32) -> Result<(), Self::Error> {	×
122	self.write_comma()?;	×
123	write!(self.writer, "{}", value)?;	×
124	self.set_comma();	×
125	Ok(())	×
126	}	×
127
128	fn serialize_f64(&mut self, value: f64) -> Result<(), Self::Error> {	×
129	self.write_comma()?;	×
130	write!(self.writer, "{}", value)?;	×
131	self.set_comma();	×
132	Ok(())	×
133	}	×
134
135	fn serialize_bool(&mut self, value: bool) -> Result<(), Self::Error> {	2✔
136	self.write_comma()?;	2✔
137	write!(self.writer, "{}", value)?;	2✔
138	self.set_comma();	2✔
139	Ok(())	2✔
140	}	2✔
141
142	fn serialize_char(&mut self, value: char) -> Result<(), Self::Error> {	×
143	self.write_comma()?;	×
144	write!(self.writer, "\"{}\"", value)?;	×
145	self.set_comma();	×
146	Ok(())	×
147	}	×
148
149	fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {	5✔
150	self.write_comma()?;	5✔
151	write!(self.writer, "\"{}\"", value)?;	5✔
152	self.set_comma();	5✔
153	Ok(())	5✔
154	}	5✔
155
NEW 156	fn serialize_bytes(	×
NEW 157	&mut self,	×
NEW 158	_len: usize,	×
NEW 159	value: impl IntoIterator<Item = impl Borrow<u8>>,	×
NEW 160	) -> Result<(), Self::Error> {	×
161	self.write_comma()?;	×
162	write!(self.writer, "[")?;	×
163
164	self.need_comma.push(false);	×
NEW 165	for byte in value.into_iter() {	×
166	self.write_comma()?;	×
NEW 167	write!(self.writer, "{}", byte.borrow())?;	×
168	self.set_comma();	×
169	}
170	self.need_comma.pop();	×
171
172	write!(self.writer, "]")?;	×
173	self.set_comma();	×
174	Ok(())	×
175	}	×
176
177	fn serialize_none(&mut self) -> Result<(), Self::Error> {	1✔
178	self.write_comma()?;	1✔
179	write!(self.writer, "null")?;	1✔
180	self.set_comma();	1✔
181	Ok(())	1✔
182	}	1✔
183
184	fn serialize_unit(&mut self) -> Result<(), Self::Error> {	×
185	self.write_comma()?;	×
186	write!(self.writer, "null")?;	×
187	self.set_comma();	×
188	Ok(())	×
189	}	×
190
191	fn serialize_unit_variant(	1✔
192	&mut self,	1✔
193	_variant_index: usize,	1✔
194	variant_name: &str,	1✔
195	) -> Result<(), Self::Error> {	1✔
196	self.write_comma()?;	1✔
197	write!(self.writer, "\"{}\"", variant_name)?;	1✔
198	self.set_comma();	1✔
199	Ok(())	1✔
200	}	1✔
201
202	fn start_object(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {	6✔
203	self.write_comma()?;	6✔
204	write!(self.writer, "{{")?;	6✔
205	self.need_comma.push(false);	6✔
206	Ok(())	6✔
207	}	6✔
208
209	fn end_object(&mut self) -> Result<(), Self::Error> {	6✔
210	self.need_comma.pop();	6✔
211	write!(self.writer, "}}")?;	6✔
212	self.set_comma();	6✔
213	Ok(())	6✔
214	}	6✔
215
216	fn start_array(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {	2✔
217	self.write_comma()?;	2✔
218	write!(self.writer, "[")?;	2✔
219	self.need_comma.push(false);	2✔
220	Ok(())	2✔
221	}	2✔
222
223	fn end_array(&mut self) -> Result<(), Self::Error> {	2✔
224	self.need_comma.pop();	2✔
225	write!(self.writer, "]")?;	2✔
226	self.set_comma();	2✔
227	Ok(())	2✔
228	}	2✔
229
230	fn start_map(&mut self, _len: Option<usize>) -> Result<(), Self::Error> {	×
231	self.write_comma()?;	×
232	write!(self.writer, "{{")?;	×
233	self.need_comma.push(false);	×
234	Ok(())	×
235	}	×
236
237	fn end_map(&mut self) -> Result<(), Self::Error> {	×
238	self.need_comma.pop();	×
239	write!(self.writer, "}}")?;	×
240	self.set_comma();	×
241	Ok(())	×
242	}	×
243
244	fn serialize_field_name(&mut self, name: &str) -> Result<(), Self::Error> {	14✔
245	self.write_comma()?;	14✔
246	write!(self.writer, "\"{}\":", name)?;	14✔
247	if let Some(need_comma) = self.need_comma.last_mut() {	14✔
248	*need_comma = false;	14✔
249	}	14✔
250	Ok(())	14✔
251	}	14✔
252	}
253
254	impl<W> DebugSerializer<W>
255	where
256	W: core::fmt::Write,
257	{
258	fn write_comma(&mut self) -> Result<(), DebugError> {	36✔
259	if let Some(&true) = self.need_comma.last() {	36✔
260	write!(self.writer, ", ")?;	11✔
261	}	25✔
262	Ok(())	36✔
263	}	36✔
264
265	fn set_comma(&mut self) {	22✔
266	if let Some(need_comma) = self.need_comma.last_mut() {	22✔
267	*need_comma = true;	22✔
268	}	22✔
269	}	22✔
270	}
271
272	#[cfg(test)]
273	mod tests {
274	use facet::Facet;
275	use facet_reflect::Peek;
276
277	use crate::serialize_iterative;
278
279	use super::DebugSerializer;
280
281	#[derive(Facet)]
282	struct FooBarBaz {
283	foo: u32,
284	bar: String,
285	baz: bool,
286	}
287
288	#[test]
289	fn test_serialize_debug() -> eyre::Result<()> {	1✔
290	facet_testhelpers::setup();	1✔
291
292	let val = FooBarBaz {	1✔
293	foo: 42,	1✔
294	bar: "Hello".to_string(),	1✔
295	baz: true,	1✔
296	};	1✔
297	let peek = Peek::new(&val);	1✔
298
299	let mut s = String::new();	1✔
300	let mut serializer = DebugSerializer {	1✔
301	writer: &mut s,	1✔
302	need_comma: vec![false],	1✔
303	};	1✔
304	serialize_iterative(peek, &mut serializer)?;	1✔
305	#[cfg(not(miri))]
306	insta::assert_snapshot!(s);	1✔
307
308	Ok(())	1✔
309	}	1✔
310
311	#[derive(Facet)]
312	struct FooBarBazContainer {
313	foo_bar_baz: FooBarBaz,
314	other_things: Vec<SomeEnum>,
315	maybe_value: Option<u32>,
316	definitely_none: Option<String>,
317	}
318
319	#[derive(Facet)]
320	#[repr(u8)]
321	#[allow(dead_code)]
322	enum SomeEnum {
323	Variant1,
324	Variant2(u32, String),
325	Variant3 { field1: u32, field2: String },
326	}
327
328	#[test]
329	fn test_serialize_debug_container() {	1✔
330	facet_testhelpers::setup();	1✔
331
332	let val = FooBarBazContainer {	1✔
333	foo_bar_baz: FooBarBaz {	1✔
334	foo: 42,	1✔
335	bar: "Hello".to_string(),	1✔
336	baz: true,	1✔
337	},	1✔
338	other_things: vec![	1✔
339	SomeEnum::Variant1,	1✔
340	SomeEnum::Variant2(123, "TupleVariant".to_string()),	1✔
341	SomeEnum::Variant3 {	1✔
342	field1: 456,	1✔
343	field2: "StructVariant".to_string(),	1✔
344	},	1✔
345	],	1✔
346	maybe_value: Some(42),	1✔
347	definitely_none: None,	1✔
348	};	1✔
349	let peek = Peek::new(&val);	1✔
350
351	let mut s = String::new();	1✔
352	let mut serializer = DebugSerializer {	1✔
353	writer: &mut s,	1✔
354	need_comma: vec![false],	1✔
355	};	1✔
356	serialize_iterative(peek, &mut serializer).unwrap();	1✔
357	#[cfg(not(miri))]
358	insta::assert_snapshot!(s);	1✔
359	}	1✔
360
361	#[derive(Facet)]
362	#[facet(transparent)]
363	#[repr(transparent)]
364	struct Wrapper(String);
365
366	#[test]
367	fn test_serialize_transparent() {	1✔
368	facet_testhelpers::setup();	1✔
369
370	let val = Wrapper("TransparentValue".to_string());	1✔
371	let peek = Peek::new(&val);	1✔
372
373	let mut s = String::new();	1✔
374	let mut serializer = DebugSerializer {	1✔
375	writer: &mut s,	1✔
376	need_comma: vec![false],	1✔
377	};	1✔
378	serialize_iterative(peek, &mut serializer).unwrap();	1✔
379	#[cfg(not(miri))]
380	insta::assert_snapshot!(s);	1✔
381	}	1✔
382	}

facet-rs / facet / 15364550646

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