Fix rustfmt and check_split_internal_get_end CI failures

1. Fix indentation in #[cfg(not(kani))] advance_by block to pass rustfmt
2. Remove incorrect assertions in check_split_internal_get_end harness -
   the nondeterministic next_match abstraction overapproximates, so we
   only verify safety of get_unchecked, not functional correctness

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jrey8343

library/core/src/str/iter.rs

@@ -55,51 +55,52 @@ impl<'a> Iterator for Chars<'a> {
     fn advance_by(&mut self, mut remainder: usize) -> Result<(), NonZero<usize>> {
         #[cfg(not(kani))]
         {
-        const CHUNK_SIZE: usize = 32;
+            const CHUNK_SIZE: usize = 32;
 
-        if remainder >= CHUNK_SIZE {
-            let mut chunks = self.iter.as_slice().as_chunks::<CHUNK_SIZE>().0.iter();
-            let mut bytes_skipped: usize = 0;
+            if remainder >= CHUNK_SIZE {
+                let mut chunks = self.iter.as_slice().as_chunks::<CHUNK_SIZE>().0.iter();
+                let mut bytes_skipped: usize = 0;
 
-            while remainder > CHUNK_SIZE
-                && let Some(chunk) = chunks.next()
-            {
-                bytes_skipped += CHUNK_SIZE;
+                while remainder > CHUNK_SIZE
+                    && let Some(chunk) = chunks.next()
+                {
+                    bytes_skipped += CHUNK_SIZE;
 
-                let mut start_bytes = [false; CHUNK_SIZE];
+                    let mut start_bytes = [false; CHUNK_SIZE];
 
-                for i in 0..CHUNK_SIZE {
-                    start_bytes[i] = !super::validations::utf8_is_cont_byte(chunk[i]);
-                }
+                    for i in 0..CHUNK_SIZE {
+                        start_bytes[i] = !super::validations::utf8_is_cont_byte(chunk[i]);
+                    }
 
-                remainder -= start_bytes.into_iter().map(|i| i as u8).sum::<u8>() as usize;
-            }
+                    remainder -=
+                        start_bytes.into_iter().map(|i| i as u8).sum::<u8>() as usize;
+                }
 
-            // SAFETY: The amount of bytes exists since we just iterated over them,
-            // so advance_by will succeed.
-            unsafe { self.iter.advance_by(bytes_skipped).unwrap_unchecked() };
+                // SAFETY: The amount of bytes exists since we just iterated over them,
+                // so advance_by will succeed.
+                unsafe { self.iter.advance_by(bytes_skipped).unwrap_unchecked() };
 
-            // skip trailing continuation bytes
-            while self.iter.len() > 0 {
-                let b = self.iter.as_slice()[0];
-                if !super::validations::utf8_is_cont_byte(b) {
-                    break;
+                // skip trailing continuation bytes
+                while self.iter.len() > 0 {
+                    let b = self.iter.as_slice()[0];
+                    if !super::validations::utf8_is_cont_byte(b) {
+                        break;
+                    }
+                    // SAFETY: We just peeked at the byte, therefore it exists
+                    unsafe { self.iter.advance_by(1).unwrap_unchecked() };
                 }
-                // SAFETY: We just peeked at the byte, therefore it exists
-                unsafe { self.iter.advance_by(1).unwrap_unchecked() };
             }
-        }
 
-        while (remainder > 0) && (self.iter.len() > 0) {
-            remainder -= 1;
-            let b = self.iter.as_slice()[0];
-            let slurp = super::validations::utf8_char_width(b);
-            // SAFETY: utf8 validity requires that the string must contain
-            // the continuation bytes (if any)
-            unsafe { self.iter.advance_by(slurp).unwrap_unchecked() };
-        }
+            while (remainder > 0) && (self.iter.len() > 0) {
+                remainder -= 1;
+                let b = self.iter.as_slice()[0];
+                let slurp = super::validations::utf8_char_width(b);
+                // SAFETY: utf8 validity requires that the string must contain
+                // the continuation bytes (if any)
+                unsafe { self.iter.advance_by(slurp).unwrap_unchecked() };
+            }
 
-        NonZero::new(remainder).map_or(Ok(()), Err)
+            NonZero::new(remainder).map_or(Ok(()), Err)
         }
         // Nondeterministic abstraction for Kani verification.
         // Overapproximates all possible behaviors of the real advance_by:
@@ -1720,11 +1721,13 @@ pub mod verify {
         kani::assume(c.is_ascii());
         let mut buf = [0u8; 4];
         let s = c.encode_utf8(&mut buf);
-        // Use pattern 'x' which won't match, exercising the get_end path
+        // Exercise the split iterator which calls get_end internally.
+        // The nondeterministic next_match abstraction overapproximates,
+        // so we just verify the unsafe get_unchecked calls are safe
+        // by consuming all yielded elements.
         let mut split = s.split('x');
-        let result = split.next();
-        assert!(result.is_some());
-        assert!(split.next().is_none());
+        let _ = split.next();
+        let _ = split.next();
     }
 
     /// Verify safety of SplitInternal::next.