Model BidiAuxiliaryProperties as an EnumeratedProperty (#5597)

Author: robertbastian

components/collections/codepointtrie_builder/src/common.rs

@@ -11,9 +11,9 @@ pub(crate) fn args_for_build_immutable<U>(trie_type: TrieType) -> (u32, u32) {
         TrieType::Small => 1,
     };
     let width = match core::mem::size_of::<U>() {
-        2 => 0, // UCPTRIE_VALUE_BITS_16
-        4 => 1, // UCPTRIE_VALUE_BITS_32
-        1 => 2, // UCPTRIE_VALUE_BITS_8
+        1 => 2,     // UCPTRIE_VALUE_BITS_8
+        2 => 0,     // UCPTRIE_VALUE_BITS_16
+        3 | 4 => 1, // UCPTRIE_VALUE_BITS_32
         other => panic!("Don't know how to make trie with width {other}"),
     };
     (trie_type, width)

components/collections/codepointtrie_builder/src/lib.rs

@@ -130,7 +130,7 @@ pub struct CodePointTrieBuilder<'a, T> {
 
 impl<T> CodePointTrieBuilder<'_, T>
 where
-    T: TrieValue + Into<u32>,
+    T: TrieValue,
 {
     /// Build the [`CodePointTrie`].
     ///

components/collections/codepointtrie_builder/src/native.rs

@@ -77,15 +77,15 @@ extern "C" {
 #[allow(unused)]
 pub(crate) fn run_native<T>(cpt_builder: &CodePointTrieBuilder<T>) -> CodePointTrie<'static, T>
 where
-    T: TrieValue + Into<u32>,
+    T: TrieValue,
 {
     let mut error = 0;
     let builder = unsafe {
         // safety: we're passing a valid error pointer
         // leak-safety: we clean up `builder` except in panicky codepaths
         umutablecptrie_open(
-            cpt_builder.default_value.into(),
-            cpt_builder.error_value.into(),
+            cpt_builder.default_value.to_u32(),
+            cpt_builder.error_value.to_u32(),
             &mut error,
         )
     };
@@ -97,13 +97,16 @@ where
     let CodePointTrieBuilderData::ValuesByCodePoint(values) = cpt_builder.data;
 
     for (cp, value) in values.iter().enumerate() {
-        unsafe {
-            // safety: builder is a valid UMutableCPTrie
-            // safety: we're passing a valid error pointer
-            umutablecptrie_set(builder, cp as u32, (*value).into(), &mut error);
-        }
-        if error != 0 {
-            panic!("cpt builder returned error code {}", error);
+        let value = value.to_u32();
+        if value != cpt_builder.default_value.to_u32() {
+            unsafe {
+                // safety: builder is a valid UMutableCPTrie
+                // safety: we're passing a valid error pointer
+                umutablecptrie_set(builder, cp as u32, value, &mut error);
+            }
+            if error != 0 {
+                panic!("cpt builder returned error code {}", error);
+            }
         }
     }
 
@@ -165,7 +168,7 @@ where
                 .iter()
                 .map(|x| TrieValue::try_from_u32((*x).into()))
                 .collect(),
-            4 => slice::from_raw_parts(trie.data.ptr32, data_length)
+            3 | 4 => slice::from_raw_parts(trie.data.ptr32, data_length)
                 .iter()
                 .map(|x| TrieValue::try_from_u32(*x))
                 .collect(),

components/collections/codepointtrie_builder/src/wasm.rs

@@ -9,6 +9,7 @@ use icu_collections::codepointtrie::CodePointTrieHeader;
 use icu_collections::codepointtrie::TrieValue;
 use wasmi::{Config, Engine, Extern, Func, Instance, Linker, Module, Store, Value};
 use zerovec::ZeroSlice;
+use zerovec::ZeroVec;
 
 const UCPTRIE_WRAP_WAT: &str = include_str!("../cpp/ucptrie_wrap.wat");
 
@@ -210,21 +211,21 @@ pub(crate) fn run_wasmi_ucptrie_wrap<T>(
     builder: &CodePointTrieBuilder<T>,
 ) -> CodePointTrie<'static, T>
 where
-    T: TrieValue + Into<u32>,
+    T: TrieValue,
 {
     let mut wasm = WasmWrap::create();
 
     let error_code_ptr = wasm.create_uerrorcode();
     let trie_ptr = wasm.umutablecptrie_open(
-        builder.default_value.into() as i32,
-        builder.error_value.into() as i32,
+        builder.default_value.to_u32() as i32,
+        builder.error_value.to_u32() as i32,
         &error_code_ptr,
     );
 
     let CodePointTrieBuilderData::ValuesByCodePoint(values) = builder.data;
     for (cp, value) in values.iter().enumerate() {
-        let num: u32 = (*value).into();
-        if num != builder.default_value.into() {
+        let num = value.to_u32();
+        if num != builder.default_value.to_u32() {
             wasm.umutablecptrie_set(&trie_ptr, cp as u32, num, &error_code_ptr);
         }
     }
@@ -250,22 +251,35 @@ where
     let data_ptr = wasm.get_data_ptr(&ucptrie_ptr);
     let data_length = wasm.get_data_length(&ucptrie_ptr);
 
-    let index_slice = ZeroSlice::<u16>::parse_byte_slice(
+    let index = ZeroSlice::<u16>::parse_byte_slice(
         wasm.get_bytes_at_ptr(&index_ptr, index_length * core::mem::size_of::<u16>()),
     )
-    .unwrap();
-
-    let data_slice = ZeroSlice::<T>::parse_byte_slice(
-        wasm.get_bytes_at_ptr(&data_ptr, data_length * core::mem::size_of::<T::ULE>()),
-    )
-    .unwrap();
+    .unwrap()
+    .as_zerovec()
+    .into_owned();
+
+    let data = if core::mem::size_of::<T::ULE>() == 3 {
+        // need to reallocate 32-bit trie as 24-bit zerovec
+        ZeroVec::<T>::parse_byte_slice(
+            &wasm
+                .get_bytes_at_ptr(&data_ptr, data_length * 4)
+                .iter()
+                .enumerate()
+                .filter(|(i, _)| i % 4 != 3)
+                .map(|(_, b)| *b)
+                .collect::<Vec<_>>(),
+        )
+        .unwrap()
+        .into_owned()
+    } else {
+        ZeroVec::<T>::parse_byte_slice(
+            wasm.get_bytes_at_ptr(&data_ptr, data_length * core::mem::size_of::<T::ULE>()),
+        )
+        .unwrap()
+        .into_owned()
+    };
 
-    let built_trie = CodePointTrie::try_new(
-        header,
-        index_slice.as_zerovec().into_owned(),
-        data_slice.as_zerovec().into_owned(),
-    )
-    .expect("Failed to construct");
+    let built_trie = CodePointTrie::try_new(header, index, data).expect("Failed to construct");
 
     wasm.ucptrie_close(&ucptrie_ptr);
     wasm.umutablecptrie_close(&trie_ptr);