refactor: move more functions to unicode/rt.rs

Move the logic for traversing the lookup tables for case conversions
into `rt.rs` along with the other helper functions along with the other
helper functions.

Author: Kmeakin

library/core/src/unicode/rt.rs

@@ -128,3 +128,30 @@ pub(super) unsafe fn skip_search<const SOR: usize, const OFFSETS: usize>(
     }
     offset_idx % 2 == 1
 }
+
+#[inline(always)]
+pub(super) fn case_conversion(
+    c: char,
+    ascii_fn: fn(char) -> char,
+    table: &[(char, u32)],
+    multi: &[[char; 3]],
+) -> [char; 3] {
+    const INDEX_MASK: u32 = 1 << 22;
+
+    if c.is_ascii() {
+        return [ascii_fn(c), '\0', '\0'];
+    }
+
+    let Ok(i) = table.binary_search_by(|&(key, _)| key.cmp(&c)) else {
+        return [c, '\0', '\0'];
+    };
+
+    let u = table[i].1;
+    match char::from_u32(u) {
+        Option::Some(c) => [c, '\0', '\0'],
+        Option::None => {
+            // SAFETY: Index comes from statically generated table
+            unsafe { *multi.get_unchecked((u & (INDEX_MASK - 1)) as usize) }
+        }
+    }
+}

library/core/src/unicode/unicode_data.rs

@@ -762,46 +762,14 @@ pub mod white_space {
 }
 
 pub mod conversions {
-    const INDEX_MASK: u32 = 1 << 22;
-
     pub fn to_lower(c: char) -> [char; 3] {
-        if c.is_ascii() {
-            [(c as u8).to_ascii_lowercase() as char, '\0', '\0']
-        } else {
-            LOWERCASE_TABLE
-                .binary_search_by(|&(key, _)| key.cmp(&c))
-                .map(|i| {
-                    let u = LOWERCASE_TABLE[i].1;
-                    char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                        // SAFETY: Index comes from statically generated table
-                        unsafe {
-                            *LOWERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize)
-                        }
-                    })
-                })
-                .unwrap_or([c, '\0', '\0'])
-        }
+        super::case_conversion(
+            c,
+            |c| c.to_ascii_lowercase(),
+            LOWERCASE_TABLE,
+            LOWERCASE_TABLE_MULTI,
+        )
     }
-
-    pub fn to_upper(c: char) -> [char; 3] {
-        if c.is_ascii() {
-            [(c as u8).to_ascii_uppercase() as char, '\0', '\0']
-        } else {
-            UPPERCASE_TABLE
-                .binary_search_by(|&(key, _)| key.cmp(&c))
-                .map(|i| {
-                    let u = UPPERCASE_TABLE[i].1;
-                    char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                        // SAFETY: Index comes from statically generated table
-                        unsafe {
-                            *UPPERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize)
-                        }
-                    })
-                })
-                .unwrap_or([c, '\0', '\0'])
-        }
-    }
-
     #[rustfmt::skip]
     static LOWERCASE_TABLE: &[(char, u32); 1462] = &[
         ('\u{c0}', 224), ('\u{c1}', 225), ('\u{c2}', 226), ('\u{c3}', 227), ('\u{c4}', 228),
@@ -1164,6 +1132,14 @@ pub mod conversions {
         ['i', '\u{307}', '\u{0}'],
     ];
 
+    pub fn to_upper(c: char) -> [char; 3] {
+        super::case_conversion(
+            c,
+            |c| c.to_ascii_uppercase(),
+            UPPERCASE_TABLE,
+            UPPERCASE_TABLE_MULTI,
+        )
+    }
     #[rustfmt::skip]
     static UPPERCASE_TABLE: &[(char, u32); 1554] = &[
         ('\u{b5}', 924), ('\u{df}', 4194304), ('\u{e0}', 192), ('\u{e1}', 193), ('\u{e2}', 194),

src/tools/unicode-table-generator/src/case_mapping.rs

@@ -9,14 +9,17 @@ pub(crate) fn generate_case_mapping(data: &UnicodeData) -> (String, [usize; 2])
     let (lower_tables, lower_size) = generate_tables("LOWER", &data.to_lower);
     let (upper_tables, upper_size) = generate_tables("UPPER", &data.to_upper);
     let file = format!(
-        "{HEADER}
+        "
         {lower_tables}
         {upper_tables}"
     );
     (file, [lower_size, upper_size])
 }
 
-fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize) {
+fn generate_tables(prop: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize) {
+    let prop_lower = prop.to_lowercase();
+    let prop_upper = prop.to_uppercase();
+
     let mut mappings = Vec::with_capacity(data.len());
     let mut multis = Vec::new();
 
@@ -45,8 +48,16 @@ fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize
     let size = size_of_val(mappings.as_slice()) + size_of_val(multis.as_slice());
     let file = format!(
         "
-    #[rustfmt::skip]\nstatic {case}CASE_TABLE: &[(char, u32); {mappings_len}] = &[{mappings}];
-    #[rustfmt::skip]\nstatic {case}CASE_TABLE_MULTI: &[[char; 3]; {multis_len}] = &[{multis}];",
+        pub fn to_{prop_lower}(c: char) -> [char; 3] {{
+            super::case_conversion(
+                c,
+                |c| c.to_ascii_{prop_lower}case(),
+                {prop_upper}CASE_TABLE,
+                {prop_upper}CASE_TABLE_MULTI,
+            )
+        }}
+    #[rustfmt::skip]\nstatic {prop_upper}CASE_TABLE: &[(char, u32); {mappings_len}] = &[{mappings}];
+    #[rustfmt::skip]\nstatic {prop_upper}CASE_TABLE_MULTI: &[[char; 3]; {multis_len}] = &[{multis}];",
         mappings = fmt_list(&mappings),
         mappings_len = mappings.len(),
         multis = fmt_list(&multis),
@@ -55,41 +66,3 @@ fn generate_tables(case: &str, data: &BTreeMap<u32, [u32; 3]>) -> (String, usize
 
     (file, size)
 }
-
-static HEADER: &str = r"
-const INDEX_MASK: u32 = 1 << 22;
-
-pub fn to_lower(c: char) -> [char; 3] {
-    if c.is_ascii() {
-        [(c as u8).to_ascii_lowercase() as char, '\0', '\0']
-    } else {
-        LOWERCASE_TABLE
-            .binary_search_by(|&(key, _)| key.cmp(&c))
-            .map(|i| {
-                let u = LOWERCASE_TABLE[i].1;
-                char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                    // SAFETY: Index comes from statically generated table
-                    unsafe { *LOWERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize) }
-                })
-            })
-            .unwrap_or([c, '\0', '\0'])
-    }
-}
-
-pub fn to_upper(c: char) -> [char; 3] {
-    if c.is_ascii() {
-        [(c as u8).to_ascii_uppercase() as char, '\0', '\0']
-    } else {
-        UPPERCASE_TABLE
-            .binary_search_by(|&(key, _)| key.cmp(&c))
-            .map(|i| {
-                let u = UPPERCASE_TABLE[i].1;
-                char::from_u32(u).map(|c| [c, '\0', '\0']).unwrap_or_else(|| {
-                    // SAFETY: Index comes from statically generated table
-                    unsafe { *UPPERCASE_TABLE_MULTI.get_unchecked((u & (INDEX_MASK - 1)) as usize) }
-                })
-            })
-            .unwrap_or([c, '\0', '\0'])
-    }
-}
-";