Make char::DecodeUtf16::size_hist more precise

library/core/src/char/decode.rs

@@ -120,9 +120,26 @@ impl<I: Iterator<Item = u16>> Iterator for DecodeUtf16<I> {
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let (low, high) = self.iter.size_hint();
-        // we could be entirely valid surrogates (2 elements per
-        // char), or entirely non-surrogates (1 element per char)
-        (low / 2, high)
+
+        // If
+        // - `self.buf` contains a non surrogate (`u < 0xD800 || 0xDFFF < u`), or
+        // - `high == Some(0)` (and `self.buf` contains a leading surrogate since
+        //   it can never contain a trailing surrogate)
+        //
+        // then buf contains an additional character or error that doesn't
+        // need a pair from `self.iter`, so it's +1 additional element.
+        let addition_from_buf =
+            self.buf.map_or(false, |u| u < 0xD800 || 0xDFFF < u || high == Some(0)) as usize;
+
+        // `self.iter` could contain entirely valid surrogates (2 elements per
+        // char), or entirely non-surrogates (1 element per char).
+        //
+        // On odd lower bound, at least one element must stay unpaired
+        // (with other elements from `self.iter`), so we round up.
+        let low = low.div_ceil(2) + addition_from_buf;
+        let high = high.and_then(|h| h.checked_add(addition_from_buf));
+
+        (low, high)
     }
 }
 

library/core/tests/char.rs

@@ -308,6 +308,32 @@ fn test_decode_utf16() {
     check(&[0xD800, 0], &[Err(0xD800), Ok('\0')]);
 }
 
+#[test]
+fn test_decode_utf16_size_hint() {
+    fn check(s: &[u16]) {
+        let mut iter = char::decode_utf16(s.iter().cloned());
+
+        loop {
+            let count = iter.clone().count();
+            let (lower, upper) = iter.size_hint();
+
+            assert!(
+                lower <= count && count <= upper.unwrap(),
+                "lower = {lower}, count = {count}, upper = {upper:?}"
+            );
+
+            if let None = iter.next() {
+                break;
+            }
+        }
+    }
+
+    check(&[0xD800, 0xD800, 0xDC00]);
+    check(&[0xD800, 0x41, 0x42]);
+    check(&[0xD800, 0]);
+    check(&[0xD834, 0x006d]);
+}
+
 #[test]
 fn ed_iterator_specializations() {
     // Check counting