Reduce amount of generated unsafe code.

reitermarkus · reitermarkus · commit 36cd81da988a · 2025-05-30T22:15:06.000+02:00
diff --git a/library/core/src/unicode/printable.py b/library/core/src/unicode/printable.py
@@ -92,8 +92,8 @@ def compress_singletons(singletons):
 
 
 def compress_normal(normal):
-    # lengths 0x00..0x7f are encoded as 00, 01, ..., 7e, 7f
-    # lengths 0x80..0x7fff are encoded as 80 80, 80 81, ..., ff fe, ff ff
+    # lengths 0x00..0x7f are encoded as 0x00, 0x01, …, 0x7e, 0x7f
+    # lengths 0x80..0x7fff are encoded as 0x8080, 0x8081, …, 0xfffe, 0xffff
     compressed = []  # [truelen, (truelenaux), falselen, (falselenaux)]
 
     prev_start = 0
@@ -108,19 +108,19 @@ def compress_normal(normal):
             entry.append(0x80 | (truelen >> 8))
             entry.append(truelen & 0xFF)
         else:
-            entry.append(truelen & 0x7F)
+            entry.append(truelen)
         if falselen > 0x7F:
             entry.append(0x80 | (falselen >> 8))
             entry.append(falselen & 0xFF)
         else:
-            entry.append(falselen & 0x7F)
+            entry.append(falselen)
 
         compressed.append(entry)
 
     return compressed
 
 
-def print_singletons(uppers, lowers, uppersname, lowersname):
+def print_singletons(name, uppers, lowers, uppersname, lowersname):
     print("#[rustfmt::skip]")
     print("const {}: &[(u8, u8)] = &[".format(uppersname))
     for u, c in uppers:
@@ -134,13 +134,15 @@ def print_singletons(uppers, lowers, uppersname, lowersname):
         )
     print("];")
 
+    print(f"const {name}: Singletons = Singletons::new(&{uppersname}, &{lowersname});")
+
 
 def print_normal(normal, normalname):
     print("#[rustfmt::skip]")
-    print("const {}: &[u8] = &[".format(normalname))
+    print("const {}: Normal = Normal::new(&[".format(normalname))
     for v in normal:
         print("    {}".format(" ".join("{:#04x},".format(i) for i in v)))
-    print("];")
+    print("]);")
 
 
 def main():
@@ -178,122 +180,49 @@ def main():
             else:
                 normal0.append((a, b - a))
 
-    SINGLETONS0_UPPER, SINGLETONS0_LOWER = compress_singletons(singletons0)
-    SINGLETONS1_UPPER, SINGLETONS1_LOWER = compress_singletons(singletons1)
+    singletons0_upper, singletons0_lower = compress_singletons(singletons0)
+    singletons1_upper, singletons1_lower = compress_singletons(singletons1)
     normal0 = compress_normal(normal0)
     normal1 = compress_normal(normal1)
 
     print("""\
 // NOTE: The following code was generated by "library/core/src/unicode/printable.py",
 //       do not edit directly!
 
-/// # Safety
-///
-/// - The sum of all lengths (i.e. the second field of each pair) in `singletons_upper` must be
-///   equal to the length of `singletons_lower`.
-/// - `normal` must be encoded such that lengths greater than `0x7f` consist of two bytes in big
-///   endian, with the highest bit set and the length contained in the remaining 15 bits.
-unsafe fn check(
-    x: u16,
-    singletons_upper: &[(u8, u8)],
-    singletons_lower: &[u8],
-    normal: &[u8],
-) -> bool {
-    let [x_upper, x_lower] = x.to_be_bytes();
-    let mut lower_start = 0;
-    for &(upper, lower_count) in singletons_upper {
-        let lower_end = lower_start + lower_count as usize;
-        if upper == x_upper {
-            // SAFETY: The caller ensures that the sum of all lengths in `singletons_upper`
-            // is equal to the length of `singletons_lower`, so `lower_end` is guaranteed to be
-            // less than `singletons_lower.len()`.
-            for &lower in unsafe { singletons_lower.get_unchecked(lower_start..lower_end) } {
-                if lower == x_lower {
-                    return false;
-                }
-            }
-        } else if x_upper < upper {
-            break;
-        }
-        lower_start = lower_end;
-    }
-
-    let mut x = x as i32;
-    let mut normal = normal.iter().cloned();
-    let mut current = true;
-    while let Some(v) = normal.next() {
-        let len = if v & 0x80 != 0 {
-            let upper = v & 0x7f;
-            // SAFETY: The encoding of `normal` is guaranteed by the caller such that
-            // if the length is greater than 0x7f, it consists of two bytes, so there
-            // must be a next byte.
-            let lower = unsafe { normal.next().unwrap_unchecked() };
-            i32::from(u16::from_be_bytes([upper, lower]))
-        } else {
-            i32::from(v)
-        };
-        x -= len;
-        if x < 0 {
-            break;
-        }
-        current = !current;
-    }
-    current
-}
+mod check;
+use check::{Normal, Singletons};
 
 pub(crate) fn is_printable(x: char) -> bool {
     let x = x as u32;
     let lower = x as u16;
 
     match x {
-        ..32 => false, // ASCII fast path
-        ..127 => true, // ASCII fast path
-        ..0x10000 => {
-            const {
-                let mut lower_count_total = 0;
-                let mut i = 0;
-                while i < SINGLETONS0_UPPER.len() {
-                    lower_count_total += SINGLETONS0_UPPER[i].1 as usize;
-                    i += 1;
-                }
-                assert!(lower_count_total == SINGLETONS0_LOWER.len());
-            }
-            // SAFETY: We just asserted that the sum of all lengths in `SINGLETONS0_UPPER` is equal
-            // to the length of `SINGLETONS0_LOWER`, and `NORMAL0` is encoded such that lengths
-            // greater than `0x7f` consist of two bytes in big endian, with the highest bit set and
-            // the length contained in the remaining 15 bits.
-            unsafe { check(lower, SINGLETONS0_UPPER, SINGLETONS0_LOWER, NORMAL0) }
-        }
-        ..0x20000 => {
-            const {
-                let mut lower_count_total = 0;
-                let mut i = 0;
-                while i < SINGLETONS1_UPPER.len() {
-                    lower_count_total += SINGLETONS1_UPPER[i].1 as usize;
-                    i += 1;
-                }
-                assert!(lower_count_total == SINGLETONS1_LOWER.len());
-            }
-            // SAFETY: We just asserted that the sum of all lengths in `SINGLETONS1_UPPER` is equal
-            // to the length of `SINGLETONS1_LOWER`, and `NORMAL1` is encoded such that lengths
-            // greater than `0x7f` consist of two bytes in big endian, with the highest bit set and
-            // the length contained in the remaining 15 bits.
-            unsafe { check(lower, SINGLETONS1_UPPER, SINGLETONS1_LOWER, NORMAL1) }
-        }\
+        ..32 => false, // ASCII fast path.
+        ..127 => true, // ASCII fast path.
+        ..0x10000 => SINGLETONS0.check(lower) && NORMAL0.check(lower),
+        ..0x20000 => SINGLETONS1.check(lower) && NORMAL1.check(lower),\
 """)
     for a, b in extra:
-        print("        0x{:x}..0x{:x} => false,".format(a, a + b))
+        print("        {:#x}..{:#x} => false,".format(a, a + b))
     print("""\
         _ => true,
     }
 }\
 """)
     print()
     print_singletons(
-        SINGLETONS0_UPPER, SINGLETONS0_LOWER, "SINGLETONS0_UPPER", "SINGLETONS0_LOWER"
+        "SINGLETONS0",
+        singletons0_upper,
+        singletons0_lower,
+        "SINGLETONS0_UPPER",
+        "SINGLETONS0_LOWER",
     )
     print_singletons(
-        SINGLETONS1_UPPER, SINGLETONS1_LOWER, "SINGLETONS1_UPPER", "SINGLETONS1_LOWER"
+        "SINGLETONS1",
+        singletons1_upper,
+        singletons1_lower,
+        "SINGLETONS1_UPPER",
+        "SINGLETONS1_LOWER",
     )
     print_normal(normal0, "NORMAL0")
     print_normal(normal1, "NORMAL1")
diff --git a/library/core/src/unicode/printable.rs b/library/core/src/unicode/printable.rs
@@ -1,99 +1,18 @@
 // NOTE: The following code was generated by "library/core/src/unicode/printable.py",
 //       do not edit directly!
 
-/// # Safety
-///
-/// - The sum of all lengths (i.e. the second field of each pair) in `singletons_upper` must be
-///   equal to the length of `singletons_lower`.
-/// - `normal` must be encoded such that lengths greater than `0x7f` consist of two bytes in big
-///   endian, with the highest bit set and the length contained in the remaining 15 bits.
-unsafe fn check(
-    x: u16,
-    singletons_upper: &[(u8, u8)],
-    singletons_lower: &[u8],
-    normal: &[u8],
-) -> bool {
-    let [x_upper, x_lower] = x.to_be_bytes();
-    let mut lower_start = 0;
-    for &(upper, lower_count) in singletons_upper {
-        let lower_end = lower_start + lower_count as usize;
-        if upper == x_upper {
-            // SAFETY: The caller ensures that the sum of all lengths in `singletons_upper`
-            // is equal to the length of `singletons_lower`, so `lower_end` is guaranteed to be
-            // less than `singletons_lower.len()`.
-            for &lower in unsafe { singletons_lower.get_unchecked(lower_start..lower_end) } {
-                if lower == x_lower {
-                    return false;
-                }
-            }
-        } else if x_upper < upper {
-            break;
-        }
-        lower_start = lower_end;
-    }
-
-    let mut x = x as i32;
-    let mut normal = normal.iter().cloned();
-    let mut current = true;
-    while let Some(v) = normal.next() {
-        let len = if v & 0x80 != 0 {
-            let upper = v & 0x7f;
-            // SAFETY: The encoding of `normal` is guaranteed by the caller such that
-            // if the length is greater than 0x7f, it consists of two bytes, so there
-            // must be a next byte.
-            let lower = unsafe { normal.next().unwrap_unchecked() };
-            i32::from(u16::from_be_bytes([upper, lower]))
-        } else {
-            i32::from(v)
-        };
-        x -= len;
-        if x < 0 {
-            break;
-        }
-        current = !current;
-    }
-    current
-}
+mod check;
+use check::{Normal, Singletons};
 
 pub(crate) fn is_printable(x: char) -> bool {
     let x = x as u32;
     let lower = x as u16;
 
     match x {
-        ..32 => false, // ASCII fast path
-        ..127 => true, // ASCII fast path
-        ..0x10000 => {
-            const {
-                let mut lower_count_total = 0;
-                let mut i = 0;
-                while i < SINGLETONS0_UPPER.len() {
-                    lower_count_total += SINGLETONS0_UPPER[i].1 as usize;
-                    i += 1;
-                }
-                assert!(lower_count_total == SINGLETONS0_LOWER.len());
-            }
-            // SAFETY: We just asserted that the sum of all lengths in `SINGLETONS0_UPPER` is equal
-            // to the length of `SINGLETONS0_LOWER`, and `NORMAL0` is encoded such that lengths
-            // greater than `0x7f` consist of two bytes in big endian, with the highest bit set and
-            // the length contained in the remaining 15 bits.
-            unsafe { check(lower, SINGLETONS0_UPPER, SINGLETONS0_LOWER, NORMAL0) }
-        }
-        ..0x20000 => {
-            const {
-                let mut lower_count_total = 0;
-                let mut i = 0;
-                while i < SINGLETONS1_UPPER.len() {
-                    lower_count_total += SINGLETONS1_UPPER[i].1 as usize;
-                    i += 1;
-                }
-                assert!(lower_count_total == SINGLETONS1_LOWER.len());
-            }
-            // SAFETY: We just asserted that the sum of all lengths in `SINGLETONS1_UPPER` is equal
-            // to the length of `SINGLETONS1_LOWER`, and `NORMAL1` is encoded such that lengths
-            // greater than `0x7f` consist of two bytes in big endian, with the highest bit set and
-            // the length contained in the remaining 15 bits.
-            unsafe { check(lower, SINGLETONS1_UPPER, SINGLETONS1_LOWER, NORMAL1) }
-        }
+        ..32 => false, // ASCII fast path.
+        ..127 => true, // ASCII fast path.
+        ..0x10000 => SINGLETONS0.check(lower) && NORMAL0.check(lower),
+        ..0x20000 => SINGLETONS1.check(lower) && NORMAL1.check(lower),
         0x2a6e0..0x2a700 => false,
         0x2b73a..0x2b740 => false,
         0x2b81e..0x2b820 => false,
@@ -191,6 +110,7 @@ const SINGLETONS0_LOWER: &[u8] = &[
     0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
     0xfe, 0xff,
 ];
+const SINGLETONS0: Singletons = Singletons::new(&SINGLETONS0_UPPER, &SINGLETONS0_LOWER);
 #[rustfmt::skip]
 const SINGLETONS1_UPPER: &[(u8, u8)] = &[
     (0x00, 6),
@@ -267,8 +187,9 @@ const SINGLETONS1_LOWER: &[u8] = &[
     0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0,
     0xd0, 0xae, 0xaf, 0x6e, 0x6f, 0xdd, 0xde, 0x93,
 ];
+const SINGLETONS1: Singletons = Singletons::new(&SINGLETONS1_UPPER, &SINGLETONS1_LOWER);
 #[rustfmt::skip]
-const NORMAL0: &[u8] = &[
+const NORMAL0: Normal = Normal::new(&[
     0x00, 0x20,
     0x5f, 0x22,
     0x82, 0xdf, 0x04,
@@ -402,9 +323,9 @@ const NORMAL0: &[u8] = &[
     0x80, 0xbe, 0x03,
     0x1b, 0x03,
     0x0f, 0x0d,
-];
+]);
 #[rustfmt::skip]
-const NORMAL1: &[u8] = &[
+const NORMAL1: Normal = Normal::new(&[
     0x5e, 0x22,
     0x7b, 0x05,
     0x03, 0x04,
@@ -624,4 +545,4 @@ const NORMAL1: &[u8] = &[
     0x1c, 0x06,
     0x09, 0x07,
     0x80, 0xfa, 0x84, 0x06,
-];
+]);
diff --git a/library/core/src/unicode/printable/check.rs b/library/core/src/unicode/printable/check.rs
