cargo fmt

nicoburns · nicoburns · commit 8545cdfed255 · 2025-09-08T17:00:27.000+01:00
diff --git a/tendril/examples/fuzz.rs b/tendril/examples/fuzz.rs
@@ -39,57 +39,57 @@ fn fuzz() {
                 buf_string.push_str(snip);
                 buf_tendril.push_slice(snip);
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             16..=31 => {
                 let (start, end) = random_slice(&mut rng, &buf_string);
                 let snip = &buf_string[start..end].to_owned();
                 buf_string.push_str(&snip);
                 buf_tendril.push_slice(&snip);
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             32..=47 => {
                 let lenstr = format!("[length = {}]", buf_tendril.len());
                 buf_string.push_str(&lenstr);
                 buf_tendril.push_slice(&lenstr);
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             48..=63 => {
                 let n = random_boundary(&mut rng, &buf_string);
                 buf_tendril.pop_front(n as u32);
                 buf_string = buf_string[n..].to_owned();
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             64..=79 => {
                 let new_len = random_boundary(&mut rng, &buf_string);
                 let n = buf_string.len() - new_len;
                 buf_string.truncate(new_len);
                 buf_tendril.pop_back(n as u32);
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             80..=90 => {
                 let (start, end) = random_slice(&mut rng, &buf_string);
                 buf_string = buf_string[start..end].to_owned();
                 buf_tendril = buf_tendril.subtendril(start as u32, (end - start) as u32);
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             91..=96 => {
                 let c = rng.gen();
                 buf_string.push(c);
                 assert!(buf_tendril.try_push_char(c).is_ok());
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             97 => {
                 buf_string.truncate(0);
                 buf_tendril.clear();
                 assert_eq!(&*buf_string, &*buf_tendril);
-            }
+            },
 
             _ => {
                 let (start, end) = random_slice(&mut rng, &buf_string);
@@ -100,7 +100,7 @@ fn fuzz() {
                     .iter()
                     .zip(tendril_slices.iter())
                     .all(|(s, t)| **s == **t));
-            }
+            },
         }
     }
 }
diff --git a/tendril/src/bench.rs b/tendril/src/bench.rs
@@ -20,10 +20,10 @@ fn index_words_string(input: &String) -> HashMap<char, Vec<String>> {
             Entry::Occupied(mut e) => {
                 let x: &mut Vec<String> = e.get_mut();
                 x.push(word);
-            }
+            },
             Entry::Vacant(e) => {
                 e.insert(vec![word]);
-            }
+            },
         }
     }
     index
@@ -39,10 +39,10 @@ fn index_words_tendril(input: &StrTendril) -> HashMap<char, Vec<StrTendril>> {
             Some((word, true)) => match index.entry(word.chars().next().unwrap()) {
                 Entry::Occupied(mut e) => {
                     e.get_mut().push(word);
-                }
+                },
                 Entry::Vacant(e) => {
                     e.insert(vec![word]);
-                }
+                },
             },
         }
     }
diff --git a/tendril/src/futf.rs b/tendril/src/futf.rs
@@ -106,7 +106,7 @@ unsafe fn decode(buf: &[u8]) -> Option<Meaning> {
             if n < 0x80 {
                 return None;
             } // Overlong
-        }
+        },
         3 => {
             n = ((*buf.get_unchecked(0) & 0b1111) as u32) << 12
                 | ((*buf.get_unchecked(1) & 0x3F) as u32) << 6
@@ -115,9 +115,9 @@ unsafe fn decode(buf: &[u8]) -> Option<Meaning> {
                 0x0000..=0x07FF => return None, // Overlong
                 0xD800..=0xDBFF => return Some(Meaning::LeadSurrogate(n as u16 - 0xD800)),
                 0xDC00..=0xDFFF => return Some(Meaning::TrailSurrogate(n as u16 - 0xDC00)),
-                _ => {}
+                _ => {},
             }
-        }
+        },
         4 => {
             n = ((*buf.get_unchecked(0) & 0b111) as u32) << 18
                 | ((*buf.get_unchecked(1) & 0x3F) as u32) << 12
@@ -126,7 +126,7 @@ unsafe fn decode(buf: &[u8]) -> Option<Meaning> {
             if n < 0x1_0000 {
                 return None;
             } // Overlong
-        }
+        },
         _ => debug_unreachable!(),
     }
 
@@ -185,7 +185,7 @@ pub fn classify<'a>(buf: &'a [u8], idx: usize) -> Option<Codepoint<'a>> {
                         meaning: Meaning::Prefix(n - avail),
                     })
                 }
-            }
+            },
             Byte::Cont => {
                 let mut start = idx;
                 let mut checked = 0;
@@ -225,7 +225,7 @@ pub fn classify<'a>(buf: &'a [u8], idx: usize) -> Option<Codepoint<'a>> {
                                     meaning: Meaning::Prefix(n - avail),
                                 });
                             }
-                        }
+                        },
                         _ => return None,
                     }
 
@@ -235,7 +235,7 @@ pub fn classify<'a>(buf: &'a [u8], idx: usize) -> Option<Codepoint<'a>> {
                         return None;
                     }
                 }
-            }
+            },
         }
     }
 }
diff --git a/tendril/src/stream.rs b/tendril/src/stream.rs
@@ -94,8 +94,8 @@ where
                         tendril.pop_back(BUFFER_SIZE - n as u32);
                         self.process(tendril);
                         break;
-                    }
-                    Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+                    },
+                    Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},
                     Err(e) => return Err(e),
                 }
             }
@@ -162,15 +162,15 @@ where
                         self.inner_sink.error("invalid byte sequence".into());
                         self.inner_sink
                             .process(Tendril::from_slice(utf8::REPLACEMENT_CHARACTER));
-                    }
+                    },
                 }
                 t.len() - rest.len()
             });
             match resume_at {
                 None => {
                     self.incomplete = Some(incomplete);
                     return;
-                }
+                },
                 Some(resume_at) => t.pop_front(resume_at as u32),
             }
         }
@@ -180,7 +180,7 @@ where
                     debug_assert!(s.as_ptr() == t.as_ptr());
                     debug_assert!(s.len() == t.len());
                     Ok(())
-                }
+                },
                 Err(utf8::DecodeError::Invalid {
                     valid_prefix,
                     invalid_sequence,
@@ -192,21 +192,21 @@ where
                         valid_prefix.len(),
                         Err(valid_prefix.len() + invalid_sequence.len()),
                     ))
-                }
+                },
                 Err(utf8::DecodeError::Incomplete {
                     valid_prefix,
                     incomplete_suffix,
                 }) => {
                     debug_assert!(valid_prefix.as_ptr() == t.as_ptr());
                     debug_assert!(valid_prefix.len() <= t.len());
                     Err((valid_prefix.len(), Ok(incomplete_suffix)))
-                }
+                },
             };
             match unborrowed_result {
                 Ok(()) => {
                     unsafe { self.inner_sink.process(t.reinterpret_without_validating()) }
                     return;
-                }
+                },
                 Err((valid_len, and_then)) => {
                     if valid_len > 0 {
                         let subtendril = t.subtendril(0, valid_len as u32);
@@ -219,15 +219,15 @@ where
                         Ok(incomplete) => {
                             self.incomplete = Some(incomplete);
                             return;
-                        }
+                        },
                         Err(offset) => {
                             self.inner_sink.error("invalid byte sequence".into());
                             self.inner_sink
                                 .process(Tendril::from_slice(utf8::REPLACEMENT_CHARACTER));
                             t.pop_front(offset as u32);
-                        }
+                        },
                     }
-                }
+                },
             }
         }
     }
@@ -365,21 +365,21 @@ where
                             debug_assert!(err.upto >= 0);
                             t.pop_front(err.upto as u32);
                             // continue loop and process remainder of t
-                        }
+                        },
                         (_, None) => break,
                     }
                 }
                 if out.len() > 0 {
                     sink.process(out);
                 }
-            }
+            },
             #[cfg(feature = "encoding_rs")]
             LossyDecoderInner::EncodingRs(ref mut decoder, ref mut sink) => {
                 if t.is_empty() {
                     return;
                 }
                 decode_to_sink(t, decoder, sink, false);
-            }
+            },
         }
     }
 
@@ -411,12 +411,12 @@ where
                     sink.process(out);
                 }
                 sink.finish()
-            }
+            },
             #[cfg(feature = "encoding_rs")]
             LossyDecoderInner::EncodingRs(mut decoder, mut sink) => {
                 decode_to_sink(Tendril::new(), &mut decoder, &mut sink, true);
                 sink.finish()
-            }
+            },
         }
     }
 }
@@ -449,11 +449,11 @@ fn decode_to_sink<Sink, A>(
         }
         match result {
             DecoderResult::InputEmpty => return,
-            DecoderResult::OutputFull => {}
+            DecoderResult::OutputFull => {},
             DecoderResult::Malformed(_, _) => {
                 sink.error(Cow::Borrowed("invalid sequence"));
                 sink.process("\u{FFFD}".into());
-            }
+            },
         }
         t.pop_front(bytes_read as u32);
         if t.is_empty() {
diff --git a/tendril/src/tendril.rs b/tendril/src/tendril.rs
@@ -1155,7 +1155,7 @@ where
                         self,
                         unsafe_slice(buf.data(), offset as usize, self.len32() as usize),
                     )
-                }
+                },
             }
         }
     }
@@ -1173,7 +1173,7 @@ where
                     let (mut buf, _, offset) = self.assume_buf();
                     let len = self.len32() as usize;
                     copy_lifetime_mut(self, unsafe_slice_mut(buf.data_mut(), offset as usize, len))
-                }
+                },
             }
         }
     }
@@ -1301,10 +1301,10 @@ where
                         if let Some((n, _)) = iter.next() {
                             skip = n as u32;
                         }
-                    }
+                    },
                     None => {
                         next_char = None;
-                    }
+                    },
                 }
             }
 
@@ -1346,7 +1346,7 @@ where
                 let t = self.clone();
                 self.clear();
                 Some((t, class))
-            }
+            },
         }
     }
 
@@ -1400,13 +1400,13 @@ where
                 Ok(0) => {
                     ret = Ok(len - start_len);
                     break;
-                }
+                },
                 Ok(n) => len += n,
-                Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+                Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},
                 Err(e) => {
                     ret = Err(e);
                     break;
-                }
+                },
             }
         }
 
@@ -1999,7 +1999,7 @@ mod test {
                     let (rt, rc) = res.unwrap();
                     assert_eq!(es, &*rt);
                     assert_eq!(ec, rc);
-                }
+                },
             }
         }
     }
diff --git a/tendril/src/utf8_decode.rs b/tendril/src/utf8_decode.rs

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ unsafe fn decode(buf: &[u8]) -> Option<Meaning> {`
`106`	`106`	`if n < 0x80 {`
`107`	`107`	`return None;`
`108`	`108`	`} // Overlong`
`109`		`- }`
	`109`	`+ },`
`110`	`110`	`3 => {`
`111`	`111`	`n = ((*buf.get_unchecked(0) & 0b1111) as u32) << 12`
`112`	`112`	`\| ((*buf.get_unchecked(1) & 0x3F) as u32) << 6`
`@@ -115,9 +115,9 @@ unsafe fn decode(buf: &[u8]) -> Option<Meaning> {`
`115`	`115`	`0x0000..=0x07FF => return None, // Overlong`
`116`	`116`	`0xD800..=0xDBFF => return Some(Meaning::LeadSurrogate(n as u16 - 0xD800)),`
`117`	`117`	`0xDC00..=0xDFFF => return Some(Meaning::TrailSurrogate(n as u16 - 0xDC00)),`
`118`		`- _ => {}`
	`118`	`+ _ => {},`
`119`	`119`	`}`
`120`		`- }`
	`120`	`+ },`
`121`	`121`	`4 => {`
`122`	`122`	`n = ((*buf.get_unchecked(0) & 0b111) as u32) << 18`
`123`	`123`	`\| ((*buf.get_unchecked(1) & 0x3F) as u32) << 12`
`@@ -126,7 +126,7 @@ unsafe fn decode(buf: &[u8]) -> Option<Meaning> {`
`126`	`126`	`if n < 0x1_0000 {`
`127`	`127`	`return None;`
`128`	`128`	`} // Overlong`
`129`		`- }`
	`129`	`+ },`
`130`	`130`	`_ => debug_unreachable!(),`
`131`	`131`	`}`
`132`	`132`
`@@ -185,7 +185,7 @@ pub fn classify<'a>(buf: &'a [u8], idx: usize) -> Option<Codepoint<'a>> {`
`185`	`185`	`meaning: Meaning::Prefix(n - avail),`
`186`	`186`	`})`
`187`	`187`	`}`
`188`		`- }`
	`188`	`+ },`
`189`	`189`	`Byte::Cont => {`
`190`	`190`	`let mut start = idx;`
`191`	`191`	`let mut checked = 0;`
`@@ -225,7 +225,7 @@ pub fn classify<'a>(buf: &'a [u8], idx: usize) -> Option<Codepoint<'a>> {`
`225`	`225`	`meaning: Meaning::Prefix(n - avail),`
`226`	`226`	`});`
`227`	`227`	`}`
`228`		`- }`
	`228`	`+ },`
`229`	`229`	`_ => return None,`
`230`	`230`	`}`
`231`	`231`
`@@ -235,7 +235,7 @@ pub fn classify<'a>(buf: &'a [u8], idx: usize) -> Option<Codepoint<'a>> {`
`235`	`235`	`return None;`
`236`	`236`	`}`
`237`	`237`	`}`
`238`		`- }`
	`238`	`+ },`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1155,7 +1155,7 @@ where`
`1155`	`1155`	`self,`
`1156`	`1156`	`unsafe_slice(buf.data(), offset as usize, self.len32() as usize),`
`1157`	`1157`	`)`
`1158`		`- }`
	`1158`	`+ },`
`1159`	`1159`	`}`
`1160`	`1160`	`}`
`1161`	`1161`	`}`
`@@ -1173,7 +1173,7 @@ where`
`1173`	`1173`	`let (mut buf, _, offset) = self.assume_buf();`
`1174`	`1174`	`let len = self.len32() as usize;`
`1175`	`1175`	`copy_lifetime_mut(self, unsafe_slice_mut(buf.data_mut(), offset as usize, len))`
`1176`		`- }`
	`1176`	`+ },`
`1177`	`1177`	`}`
`1178`	`1178`	`}`
`1179`	`1179`	`}`
`@@ -1301,10 +1301,10 @@ where`
`1301`	`1301`	`if let Some((n, _)) = iter.next() {`
`1302`	`1302`	`skip = n as u32;`
`1303`	`1303`	`}`
`1304`		`- }`
	`1304`	`+ },`
`1305`	`1305`	`None => {`
`1306`	`1306`	`next_char = None;`
`1307`		`- }`
	`1307`	`+ },`
`1308`	`1308`	`}`
`1309`	`1309`	`}`
`1310`	`1310`
`@@ -1346,7 +1346,7 @@ where`
`1346`	`1346`	`let t = self.clone();`
`1347`	`1347`	`self.clear();`
`1348`	`1348`	`Some((t, class))`
`1349`		`- }`
	`1349`	`+ },`
`1350`	`1350`	`}`
`1351`	`1351`	`}`
`1352`	`1352`
`@@ -1400,13 +1400,13 @@ where`
`1400`	`1400`	`Ok(0) => {`
`1401`	`1401`	`ret = Ok(len - start_len);`
`1402`	`1402`	`break;`
`1403`		`- }`
	`1403`	`+ },`
`1404`	`1404`	`Ok(n) => len += n,`
`1405`		`- Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}`
	`1405`	`+ Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {},`
`1406`	`1406`	`Err(e) => {`
`1407`	`1407`	`ret = Err(e);`
`1408`	`1408`	`break;`
`1409`		`- }`
	`1409`	`+ },`
`1410`	`1410`	`}`
`1411`	`1411`	`}`
`1412`	`1412`
`@@ -1999,7 +1999,7 @@ mod test {`
`1999`	`1999`	`let (rt, rc) = res.unwrap();`
`2000`	`2000`	`assert_eq!(es, &*rt);`
`2001`	`2001`	`assert_eq!(ec, rc);`
`2002`		`- }`
	`2002`	`+ },`
`2003`	`2003`	`}`
`2004`	`2004`	`}`
`2005`	`2005`	`}`