fix clippy warnings

VoidStarKat · VoidStarKat · commit c1053c3445f6 · 2025-03-15T15:49:55.000-04:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -597,7 +597,7 @@ const fn is_utf16_low_surrogate(u: u16) -> bool {
 /// Convert a UTF-16 surrogate pair to a `char`. Does not validate if the surrogates are valid.
 #[inline(always)]
 unsafe fn decode_utf16_surrogate_pair(high: u16, low: u16) -> char {
-    let c: u32 = (((high - 0xD800) as u32) << 10 | ((low) - 0xDC00) as u32) + 0x1_0000;
+    let c: u32 = ((((high - 0xD800) as u32) << 10) | ((low) - 0xDC00) as u32) + 0x1_0000;
     // SAFETY: we checked that it's a legal unicode value
     core::char::from_u32_unchecked(c)
 }
diff --git a/src/platform/windows.rs b/src/platform/windows.rs
@@ -1,4 +1,3 @@
-#![cfg(windows)]
 use std::ffi::{OsStr, OsString};
 use std::os::windows::ffi::{OsStrExt, OsStringExt};
 
diff --git a/src/ucstr.rs b/src/ucstr.rs
@@ -1990,21 +1990,21 @@ pub struct Display<'a, S: ?Sized> {
     str: &'a S,
 }
 
-impl<'a> core::fmt::Debug for Display<'a, U16CStr> {
+impl core::fmt::Debug for Display<'_, U16CStr> {
     #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         core::fmt::Debug::fmt(&self.str, f)
     }
 }
 
-impl<'a> core::fmt::Debug for Display<'a, U32CStr> {
+impl core::fmt::Debug for Display<'_, U32CStr> {
     #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         core::fmt::Debug::fmt(&self.str, f)
     }
 }
 
-impl<'a> core::fmt::Display for Display<'a, U16CStr> {
+impl core::fmt::Display for Display<'_, U16CStr> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         for c in crate::decode_utf16_lossy(self.str.as_slice().iter().copied()) {
             // Allow alternate {:#} format which skips replacment chars entirely
@@ -2016,7 +2016,7 @@ impl<'a> core::fmt::Display for Display<'a, U16CStr> {
     }
 }
 
-impl<'a> core::fmt::Display for Display<'a, U32CStr> {
+impl core::fmt::Display for Display<'_, U32CStr> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         for c in crate::decode_utf32_lossy(self.str.as_slice().iter().copied()) {
             // Allow alternate {:#} format which skips replacment chars entirely
diff --git a/src/ustr.rs b/src/ustr.rs
@@ -1317,21 +1317,21 @@ pub struct Display<'a, S: ?Sized> {
     str: &'a S,
 }
 
-impl<'a> core::fmt::Debug for Display<'a, U16Str> {
+impl core::fmt::Debug for Display<'_, U16Str> {
     #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         core::fmt::Debug::fmt(&self.str, f)
     }
 }
 
-impl<'a> core::fmt::Debug for Display<'a, U32Str> {
+impl core::fmt::Debug for Display<'_, U32Str> {
     #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         core::fmt::Debug::fmt(&self.str, f)
     }
 }
 
-impl<'a> core::fmt::Display for Display<'a, U16Str> {
+impl core::fmt::Display for Display<'_, U16Str> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         for c in crate::decode_utf16_lossy(self.str.as_slice().iter().copied()) {
             // Allow alternate {:#} format which skips replacment chars entirely
@@ -1343,7 +1343,7 @@ impl<'a> core::fmt::Display for Display<'a, U16Str> {
     }
 }
 
-impl<'a> core::fmt::Display for Display<'a, U32Str> {
+impl core::fmt::Display for Display<'_, U32Str> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         for c in crate::decode_utf32_lossy(self.str.as_slice().iter().copied()) {
             // Allow alternate {:#} format which skips replacment chars entirely
diff --git a/src/ustr/iter.rs b/src/ustr/iter.rs
@@ -24,7 +24,7 @@ impl<'a> CharsUtf16<'a> {
     }
 }
 
-impl<'a> Iterator for CharsUtf16<'a> {
+impl Iterator for CharsUtf16<'_> {
     type Item = Result<char, DecodeUtf16Error>;
 
     #[inline]
@@ -38,16 +38,16 @@ impl<'a> Iterator for CharsUtf16<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharsUtf16<'a> {}
+impl FusedIterator for CharsUtf16<'_> {}
 
-impl<'a> DoubleEndedIterator for CharsUtf16<'a> {
+impl DoubleEndedIterator for CharsUtf16<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         self.inner.next_back()
     }
 }
 
-impl<'a> core::fmt::Debug for CharsUtf16<'a> {
+impl core::fmt::Debug for CharsUtf16<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         crate::debug_fmt_utf16_iter(self.clone(), f)
     }
@@ -69,7 +69,7 @@ impl<'a> CharsUtf32<'a> {
     }
 }
 
-impl<'a> Iterator for CharsUtf32<'a> {
+impl Iterator for CharsUtf32<'_> {
     type Item = Result<char, DecodeUtf32Error>;
 
     #[inline]
@@ -83,23 +83,23 @@ impl<'a> Iterator for CharsUtf32<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharsUtf32<'a> {}
+impl FusedIterator for CharsUtf32<'_> {}
 
-impl<'a> DoubleEndedIterator for CharsUtf32<'a> {
+impl DoubleEndedIterator for CharsUtf32<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         self.inner.next_back()
     }
 }
 
-impl<'a> ExactSizeIterator for CharsUtf32<'a> {
+impl ExactSizeIterator for CharsUtf32<'_> {
     #[inline]
     fn len(&self) -> usize {
         self.inner.len()
     }
 }
 
-impl<'a> core::fmt::Debug for CharsUtf32<'a> {
+impl core::fmt::Debug for CharsUtf32<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         crate::debug_fmt_utf32_iter(self.clone(), f)
     }
@@ -121,7 +121,7 @@ impl<'a> CharsLossyUtf16<'a> {
     }
 }
 
-impl<'a> Iterator for CharsLossyUtf16<'a> {
+impl Iterator for CharsLossyUtf16<'_> {
     type Item = char;
 
     #[inline]
@@ -135,16 +135,16 @@ impl<'a> Iterator for CharsLossyUtf16<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharsLossyUtf16<'a> {}
+impl FusedIterator for CharsLossyUtf16<'_> {}
 
-impl<'a> DoubleEndedIterator for CharsLossyUtf16<'a> {
+impl DoubleEndedIterator for CharsLossyUtf16<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         self.iter.next_back()
     }
 }
 
-impl<'a> core::fmt::Debug for CharsLossyUtf16<'a> {
+impl core::fmt::Debug for CharsLossyUtf16<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         crate::debug_fmt_char_iter(self.clone(), f)
     }
@@ -166,7 +166,7 @@ impl<'a> CharsLossyUtf32<'a> {
     }
 }
 
-impl<'a> Iterator for CharsLossyUtf32<'a> {
+impl Iterator for CharsLossyUtf32<'_> {
     type Item = char;
 
     #[inline]
@@ -180,23 +180,23 @@ impl<'a> Iterator for CharsLossyUtf32<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharsLossyUtf32<'a> {}
+impl FusedIterator for CharsLossyUtf32<'_> {}
 
-impl<'a> DoubleEndedIterator for CharsLossyUtf32<'a> {
+impl DoubleEndedIterator for CharsLossyUtf32<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         self.iter.next_back()
     }
 }
 
-impl<'a> ExactSizeIterator for CharsLossyUtf32<'a> {
+impl ExactSizeIterator for CharsLossyUtf32<'_> {
     #[inline]
     fn len(&self) -> usize {
         self.iter.len()
     }
 }
 
-impl<'a> core::fmt::Debug for CharsLossyUtf32<'a> {
+impl core::fmt::Debug for CharsLossyUtf32<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         crate::debug_fmt_char_iter(self.clone(), f)
     }
@@ -230,7 +230,7 @@ impl<'a> CharIndicesUtf16<'a> {
     }
 }
 
-impl<'a> Iterator for CharIndicesUtf16<'a> {
+impl Iterator for CharIndicesUtf16<'_> {
     type Item = (usize, Result<char, DecodeUtf16Error>);
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -255,9 +255,9 @@ impl<'a> Iterator for CharIndicesUtf16<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharIndicesUtf16<'a> {}
+impl FusedIterator for CharIndicesUtf16<'_> {}
 
-impl<'a> DoubleEndedIterator for CharIndicesUtf16<'a> {
+impl DoubleEndedIterator for CharIndicesUtf16<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         match self.iter.next_back() {
@@ -302,7 +302,7 @@ impl<'a> CharIndicesUtf32<'a> {
     }
 }
 
-impl<'a> Iterator for CharIndicesUtf32<'a> {
+impl Iterator for CharIndicesUtf32<'_> {
     type Item = (usize, Result<char, DecodeUtf32Error>);
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -327,9 +327,9 @@ impl<'a> Iterator for CharIndicesUtf32<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharIndicesUtf32<'a> {}
+impl FusedIterator for CharIndicesUtf32<'_> {}
 
-impl<'a> DoubleEndedIterator for CharIndicesUtf32<'a> {
+impl DoubleEndedIterator for CharIndicesUtf32<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         match self.iter.next_back() {
@@ -346,7 +346,7 @@ impl<'a> DoubleEndedIterator for CharIndicesUtf32<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for CharIndicesUtf32<'a> {
+impl ExactSizeIterator for CharIndicesUtf32<'_> {
     #[inline]
     fn len(&self) -> usize {
         self.iter.len()
@@ -381,7 +381,7 @@ impl<'a> CharIndicesLossyUtf16<'a> {
     }
 }
 
-impl<'a> Iterator for CharIndicesLossyUtf16<'a> {
+impl Iterator for CharIndicesLossyUtf16<'_> {
     type Item = (usize, char);
 
     #[inline]
@@ -402,9 +402,9 @@ impl<'a> Iterator for CharIndicesLossyUtf16<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharIndicesLossyUtf16<'a> {}
+impl FusedIterator for CharIndicesLossyUtf16<'_> {}
 
-impl<'a> DoubleEndedIterator for CharIndicesLossyUtf16<'a> {
+impl DoubleEndedIterator for CharIndicesLossyUtf16<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         match self.iter.next_back() {
@@ -445,7 +445,7 @@ impl<'a> CharIndicesLossyUtf32<'a> {
     }
 }
 
-impl<'a> Iterator for CharIndicesLossyUtf32<'a> {
+impl Iterator for CharIndicesLossyUtf32<'_> {
     type Item = (usize, char);
 
     #[inline]
@@ -466,9 +466,9 @@ impl<'a> Iterator for CharIndicesLossyUtf32<'a> {
     }
 }
 
-impl<'a> FusedIterator for CharIndicesLossyUtf32<'a> {}
+impl FusedIterator for CharIndicesLossyUtf32<'_> {}
 
-impl<'a> DoubleEndedIterator for CharIndicesLossyUtf32<'a> {
+impl DoubleEndedIterator for CharIndicesLossyUtf32<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         match self.iter.next_back() {
@@ -481,7 +481,7 @@ impl<'a> DoubleEndedIterator for CharIndicesLossyUtf32<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for CharIndicesLossyUtf32<'a> {
+impl ExactSizeIterator for CharIndicesLossyUtf32<'_> {
     #[inline]
     fn len(&self) -> usize {
         self.iter.len()
diff --git a/src/utfstr/iter.rs b/src/utfstr/iter.rs

Original file line number	Diff line number	Diff line change
`@@ -597,7 +597,7 @@ const fn is_utf16_low_surrogate(u: u16) -> bool {`
`597`	`597`	/// Convert a UTF-16 surrogate pair to a `char`. Does not validate if the surrogates are valid.
`598`	`598`	`#[inline(always)]`
`599`	`599`	`unsafe fn decode_utf16_surrogate_pair(high: u16, low: u16) -> char {`
`600`		`- let c: u32 = (((high - 0xD800) as u32) << 10 \| ((low) - 0xDC00) as u32) + 0x1_0000;`
	`600`	`+ let c: u32 = ((((high - 0xD800) as u32) << 10) \| ((low) - 0xDC00) as u32) + 0x1_0000;`
`601`	`601`	`// SAFETY: we checked that it's a legal unicode value`
`602`	`602`	`core::char::from_u32_unchecked(c)`
`603`	`603`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-#![cfg(windows)]`
`2`	`1`	`use std::ffi::{OsStr, OsString};`
`3`	`2`	`use std::os::windows::ffi::{OsStrExt, OsStringExt};`
`4`	`3`
Original file line number	Diff line number	Diff line change
`@@ -1990,21 +1990,21 @@ pub struct Display<'a, S: ?Sized> {`
`1990`	`1990`	`str: &'a S,`
`1991`	`1991`	`}`
`1992`	`1992`
`1993`		`-impl<'a> core::fmt::Debug for Display<'a, U16CStr> {`
	`1993`	`+impl core::fmt::Debug for Display<'_, U16CStr> {`
`1994`	`1994`	`#[inline]`
`1995`	`1995`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`1996`	`1996`	`core::fmt::Debug::fmt(&self.str, f)`
`1997`	`1997`	`}`
`1998`	`1998`	`}`
`1999`	`1999`
`2000`		`-impl<'a> core::fmt::Debug for Display<'a, U32CStr> {`
	`2000`	`+impl core::fmt::Debug for Display<'_, U32CStr> {`
`2001`	`2001`	`#[inline]`
`2002`	`2002`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`2003`	`2003`	`core::fmt::Debug::fmt(&self.str, f)`
`2004`	`2004`	`}`
`2005`	`2005`	`}`
`2006`	`2006`
`2007`		`-impl<'a> core::fmt::Display for Display<'a, U16CStr> {`
	`2007`	`+impl core::fmt::Display for Display<'_, U16CStr> {`
`2008`	`2008`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`2009`	`2009`	`for c in crate::decode_utf16_lossy(self.str.as_slice().iter().copied()) {`
`2010`	`2010`	`// Allow alternate {:#} format which skips replacment chars entirely`
`@@ -2016,7 +2016,7 @@ impl<'a> core::fmt::Display for Display<'a, U16CStr> {`
`2016`	`2016`	`}`
`2017`	`2017`	`}`
`2018`	`2018`
`2019`		`-impl<'a> core::fmt::Display for Display<'a, U32CStr> {`
	`2019`	`+impl core::fmt::Display for Display<'_, U32CStr> {`
`2020`	`2020`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`2021`	`2021`	`for c in crate::decode_utf32_lossy(self.str.as_slice().iter().copied()) {`
`2022`	`2022`	`// Allow alternate {:#} format which skips replacment chars entirely`
Original file line number	Diff line number	Diff line change
`@@ -1317,21 +1317,21 @@ pub struct Display<'a, S: ?Sized> {`
`1317`	`1317`	`str: &'a S,`
`1318`	`1318`	`}`
`1319`	`1319`
`1320`		`-impl<'a> core::fmt::Debug for Display<'a, U16Str> {`
	`1320`	`+impl core::fmt::Debug for Display<'_, U16Str> {`
`1321`	`1321`	`#[inline]`
`1322`	`1322`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`1323`	`1323`	`core::fmt::Debug::fmt(&self.str, f)`
`1324`	`1324`	`}`
`1325`	`1325`	`}`
`1326`	`1326`
`1327`		`-impl<'a> core::fmt::Debug for Display<'a, U32Str> {`
	`1327`	`+impl core::fmt::Debug for Display<'_, U32Str> {`
`1328`	`1328`	`#[inline]`
`1329`	`1329`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`1330`	`1330`	`core::fmt::Debug::fmt(&self.str, f)`
`1331`	`1331`	`}`
`1332`	`1332`	`}`
`1333`	`1333`
`1334`		`-impl<'a> core::fmt::Display for Display<'a, U16Str> {`
	`1334`	`+impl core::fmt::Display for Display<'_, U16Str> {`
`1335`	`1335`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`1336`	`1336`	`for c in crate::decode_utf16_lossy(self.str.as_slice().iter().copied()) {`
`1337`	`1337`	`// Allow alternate {:#} format which skips replacment chars entirely`
`@@ -1343,7 +1343,7 @@ impl<'a> core::fmt::Display for Display<'a, U16Str> {`
`1343`	`1343`	`}`
`1344`	`1344`	`}`
`1345`	`1345`
`1346`		`-impl<'a> core::fmt::Display for Display<'a, U32Str> {`
	`1346`	`+impl core::fmt::Display for Display<'_, U32Str> {`
`1347`	`1347`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`1348`	`1348`	`for c in crate::decode_utf32_lossy(self.str.as_slice().iter().copied()) {`
`1349`	`1349`	`// Allow alternate {:#} format which skips replacment chars entirely`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ impl<'a> CharsUtf16<'a> {`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`27`		`-impl<'a> Iterator for CharsUtf16<'a> {`
	`27`	`+impl Iterator for CharsUtf16<'_> {`
`28`	`28`	`type Item = Result<char, DecodeUtf16Error>;`
`29`	`29`
`30`	`30`	`#[inline]`
`@@ -38,16 +38,16 @@ impl<'a> Iterator for CharsUtf16<'a> {`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`		`-impl<'a> FusedIterator for CharsUtf16<'a> {}`
	`41`	`+impl FusedIterator for CharsUtf16<'_> {}`
`42`	`42`
`43`		`-impl<'a> DoubleEndedIterator for CharsUtf16<'a> {`
	`43`	`+impl DoubleEndedIterator for CharsUtf16<'_> {`
`44`	`44`	`#[inline]`
`45`	`45`	`fn next_back(&mut self) -> Option<Self::Item> {`
`46`	`46`	`self.inner.next_back()`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`-impl<'a> core::fmt::Debug for CharsUtf16<'a> {`
	`50`	`+impl core::fmt::Debug for CharsUtf16<'_> {`
`51`	`51`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`52`	`52`	`crate::debug_fmt_utf16_iter(self.clone(), f)`
`53`	`53`	`}`
`@@ -69,7 +69,7 @@ impl<'a> CharsUtf32<'a> {`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`-impl<'a> Iterator for CharsUtf32<'a> {`
	`72`	`+impl Iterator for CharsUtf32<'_> {`
`73`	`73`	`type Item = Result<char, DecodeUtf32Error>;`
`74`	`74`
`75`	`75`	`#[inline]`
`@@ -83,23 +83,23 @@ impl<'a> Iterator for CharsUtf32<'a> {`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`		`-impl<'a> FusedIterator for CharsUtf32<'a> {}`
	`86`	`+impl FusedIterator for CharsUtf32<'_> {}`
`87`	`87`
`88`		`-impl<'a> DoubleEndedIterator for CharsUtf32<'a> {`
	`88`	`+impl DoubleEndedIterator for CharsUtf32<'_> {`
`89`	`89`	`#[inline]`
`90`	`90`	`fn next_back(&mut self) -> Option<Self::Item> {`
`91`	`91`	`self.inner.next_back()`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`
`95`		`-impl<'a> ExactSizeIterator for CharsUtf32<'a> {`
	`95`	`+impl ExactSizeIterator for CharsUtf32<'_> {`
`96`	`96`	`#[inline]`
`97`	`97`	`fn len(&self) -> usize {`
`98`	`98`	`self.inner.len()`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`-impl<'a> core::fmt::Debug for CharsUtf32<'a> {`
	`102`	`+impl core::fmt::Debug for CharsUtf32<'_> {`
`103`	`103`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`104`	`104`	`crate::debug_fmt_utf32_iter(self.clone(), f)`
`105`	`105`	`}`
`@@ -121,7 +121,7 @@ impl<'a> CharsLossyUtf16<'a> {`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`
`124`		`-impl<'a> Iterator for CharsLossyUtf16<'a> {`
	`124`	`+impl Iterator for CharsLossyUtf16<'_> {`
`125`	`125`	`type Item = char;`
`126`	`126`
`127`	`127`	`#[inline]`
`@@ -135,16 +135,16 @@ impl<'a> Iterator for CharsLossyUtf16<'a> {`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`
`138`		`-impl<'a> FusedIterator for CharsLossyUtf16<'a> {}`
	`138`	`+impl FusedIterator for CharsLossyUtf16<'_> {}`
`139`	`139`
`140`		`-impl<'a> DoubleEndedIterator for CharsLossyUtf16<'a> {`
	`140`	`+impl DoubleEndedIterator for CharsLossyUtf16<'_> {`
`141`	`141`	`#[inline]`
`142`	`142`	`fn next_back(&mut self) -> Option<Self::Item> {`
`143`	`143`	`self.iter.next_back()`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`147`		`-impl<'a> core::fmt::Debug for CharsLossyUtf16<'a> {`
	`147`	`+impl core::fmt::Debug for CharsLossyUtf16<'_> {`
`148`	`148`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`149`	`149`	`crate::debug_fmt_char_iter(self.clone(), f)`
`150`	`150`	`}`
`@@ -166,7 +166,7 @@ impl<'a> CharsLossyUtf32<'a> {`
`166`	`166`	`}`
`167`	`167`	`}`
`168`	`168`
`169`		`-impl<'a> Iterator for CharsLossyUtf32<'a> {`
	`169`	`+impl Iterator for CharsLossyUtf32<'_> {`
`170`	`170`	`type Item = char;`
`171`	`171`
`172`	`172`	`#[inline]`
`@@ -180,23 +180,23 @@ impl<'a> Iterator for CharsLossyUtf32<'a> {`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`		`-impl<'a> FusedIterator for CharsLossyUtf32<'a> {}`
	`183`	`+impl FusedIterator for CharsLossyUtf32<'_> {}`
`184`	`184`
`185`		`-impl<'a> DoubleEndedIterator for CharsLossyUtf32<'a> {`
	`185`	`+impl DoubleEndedIterator for CharsLossyUtf32<'_> {`
`186`	`186`	`#[inline]`
`187`	`187`	`fn next_back(&mut self) -> Option<Self::Item> {`
`188`	`188`	`self.iter.next_back()`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`
`192`		`-impl<'a> ExactSizeIterator for CharsLossyUtf32<'a> {`
	`192`	`+impl ExactSizeIterator for CharsLossyUtf32<'_> {`
`193`	`193`	`#[inline]`
`194`	`194`	`fn len(&self) -> usize {`
`195`	`195`	`self.iter.len()`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`199`		`-impl<'a> core::fmt::Debug for CharsLossyUtf32<'a> {`
	`199`	`+impl core::fmt::Debug for CharsLossyUtf32<'_> {`
`200`	`200`	`fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`201`	`201`	`crate::debug_fmt_char_iter(self.clone(), f)`
`202`	`202`	`}`
`@@ -230,7 +230,7 @@ impl<'a> CharIndicesUtf16<'a> {`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`233`		`-impl<'a> Iterator for CharIndicesUtf16<'a> {`
	`233`	`+impl Iterator for CharIndicesUtf16<'_> {`
`234`	`234`	`type Item = (usize, Result<char, DecodeUtf16Error>);`
`235`	`235`
`236`	`236`	`fn next(&mut self) -> Option<Self::Item> {`
`@@ -255,9 +255,9 @@ impl<'a> Iterator for CharIndicesUtf16<'a> {`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`258`		`-impl<'a> FusedIterator for CharIndicesUtf16<'a> {}`
	`258`	`+impl FusedIterator for CharIndicesUtf16<'_> {}`
`259`	`259`
`260`		`-impl<'a> DoubleEndedIterator for CharIndicesUtf16<'a> {`
	`260`	`+impl DoubleEndedIterator for CharIndicesUtf16<'_> {`
`261`	`261`	`#[inline]`
`262`	`262`	`fn next_back(&mut self) -> Option<Self::Item> {`
`263`	`263`	`match self.iter.next_back() {`
`@@ -302,7 +302,7 @@ impl<'a> CharIndicesUtf32<'a> {`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`
`305`		`-impl<'a> Iterator for CharIndicesUtf32<'a> {`
	`305`	`+impl Iterator for CharIndicesUtf32<'_> {`
`306`	`306`	`type Item = (usize, Result<char, DecodeUtf32Error>);`
`307`	`307`
`308`	`308`	`fn next(&mut self) -> Option<Self::Item> {`
`@@ -327,9 +327,9 @@ impl<'a> Iterator for CharIndicesUtf32<'a> {`
`327`	`327`	`}`
`328`	`328`	`}`
`329`	`329`
`330`		`-impl<'a> FusedIterator for CharIndicesUtf32<'a> {}`
	`330`	`+impl FusedIterator for CharIndicesUtf32<'_> {}`
`331`	`331`
`332`		`-impl<'a> DoubleEndedIterator for CharIndicesUtf32<'a> {`
	`332`	`+impl DoubleEndedIterator for CharIndicesUtf32<'_> {`
`333`	`333`	`#[inline]`
`334`	`334`	`fn next_back(&mut self) -> Option<Self::Item> {`
`335`	`335`	`match self.iter.next_back() {`
`@@ -346,7 +346,7 @@ impl<'a> DoubleEndedIterator for CharIndicesUtf32<'a> {`
`346`	`346`	`}`
`347`	`347`	`}`
`348`	`348`
`349`		`-impl<'a> ExactSizeIterator for CharIndicesUtf32<'a> {`
	`349`	`+impl ExactSizeIterator for CharIndicesUtf32<'_> {`
`350`	`350`	`#[inline]`
`351`	`351`	`fn len(&self) -> usize {`
`352`	`352`	`self.iter.len()`
`@@ -381,7 +381,7 @@ impl<'a> CharIndicesLossyUtf16<'a> {`
`381`	`381`	`}`
`382`	`382`	`}`
`383`	`383`
`384`		`-impl<'a> Iterator for CharIndicesLossyUtf16<'a> {`
	`384`	`+impl Iterator for CharIndicesLossyUtf16<'_> {`
`385`	`385`	`type Item = (usize, char);`
`386`	`386`
`387`	`387`	`#[inline]`
`@@ -402,9 +402,9 @@ impl<'a> Iterator for CharIndicesLossyUtf16<'a> {`
`402`	`402`	`}`
`403`	`403`	`}`
`404`	`404`
`405`		`-impl<'a> FusedIterator for CharIndicesLossyUtf16<'a> {}`
	`405`	`+impl FusedIterator for CharIndicesLossyUtf16<'_> {}`
`406`	`406`
`407`		`-impl<'a> DoubleEndedIterator for CharIndicesLossyUtf16<'a> {`
	`407`	`+impl DoubleEndedIterator for CharIndicesLossyUtf16<'_> {`
`408`	`408`	`#[inline]`
`409`	`409`	`fn next_back(&mut self) -> Option<Self::Item> {`
`410`	`410`	`match self.iter.next_back() {`
`@@ -445,7 +445,7 @@ impl<'a> CharIndicesLossyUtf32<'a> {`
`445`	`445`	`}`
`446`	`446`	`}`
`447`	`447`
`448`		`-impl<'a> Iterator for CharIndicesLossyUtf32<'a> {`
	`448`	`+impl Iterator for CharIndicesLossyUtf32<'_> {`
`449`	`449`	`type Item = (usize, char);`
`450`	`450`
`451`	`451`	`#[inline]`
`@@ -466,9 +466,9 @@ impl<'a> Iterator for CharIndicesLossyUtf32<'a> {`
`466`	`466`	`}`
`467`	`467`	`}`
`468`	`468`
`469`		`-impl<'a> FusedIterator for CharIndicesLossyUtf32<'a> {}`
	`469`	`+impl FusedIterator for CharIndicesLossyUtf32<'_> {}`
`470`	`470`
`471`		`-impl<'a> DoubleEndedIterator for CharIndicesLossyUtf32<'a> {`
	`471`	`+impl DoubleEndedIterator for CharIndicesLossyUtf32<'_> {`
`472`	`472`	`#[inline]`
`473`	`473`	`fn next_back(&mut self) -> Option<Self::Item> {`
`474`	`474`	`match self.iter.next_back() {`
`@@ -481,7 +481,7 @@ impl<'a> DoubleEndedIterator for CharIndicesLossyUtf32<'a> {`
`481`	`481`	`}`
`482`	`482`	`}`
`483`	`483`
`484`		`-impl<'a> ExactSizeIterator for CharIndicesLossyUtf32<'a> {`
	`484`	`+impl ExactSizeIterator for CharIndicesLossyUtf32<'_> {`
`485`	`485`	`#[inline]`
`486`	`486`	`fn len(&self) -> usize {`
`487`	`487`	`self.iter.len()`