15755933356

Committed 19 Jun 2025 10:42AM UTC coverage: 59.611% (+0.04%) from 59.571%

Build # 15755933356

Build Type

push

github

Committed by

fasterthanlime

Commit Message

Apply modern clippy fixes (mostly format strings)

Run Details

79 of 200 new or added lines in 29 files covered. (39.5%)

1 existing line in 1 file now uncovered.

10839 of 18183 relevant lines covered (59.61%)

150.56 hits per line

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

52.55

/facet-serialize/src/debug_serializer.rs

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, value: &[u8]) -> Result<(), Self::Error> {
        self.write_comma()?;
        write!(self.writer, "[")?;

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

facet-rs / facet / 15755933356

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