consolidate special primaries code

Author: robertbastian

components/collator/src/comparison.rs

@@ -26,9 +26,7 @@ use crate::elements::{
     QUATERNARY_MASK,
 };
 use crate::options::CollatorOptionsBitField;
-use crate::options::{
-    AlternateHandling, CollatorOptions, MaxVariable, ResolvedCollatorOptions, Strength,
-};
+use crate::options::{AlternateHandling, CollatorOptions, ResolvedCollatorOptions, Strength};
 use crate::preferences::{CollationCaseFirst, CollationNumericOrdering, CollationType};
 use crate::provider::CollationData;
 use crate::provider::CollationDiacritics;
@@ -648,28 +646,7 @@ impl Collator {
         let locale_dependent =
             LocaleSpecificDataHolder::try_new_unstable_internal(provider, prefs, options)?;
 
-        let special_primaries = special_primaries.map_project(|csp, _| {
-            let compressible_bytes = (csp.last_primaries.len()
-                == MaxVariable::Currency as usize + 16)
-                .then(|| {
-                    csp.last_primaries
-                        .as_maybe_borrowed()?
-                        .as_ule_slice()
-                        .get((MaxVariable::Currency as usize)..)?
-                        .try_into()
-                        .ok()
-                })
-                .flatten()
-                .unwrap_or(
-                    CollationSpecialPrimariesValidated::HARDCODED_COMPRESSIBLE_BYTES_FALLBACK,
-                );
-
-            CollationSpecialPrimariesValidated {
-                last_primaries: csp.last_primaries.truncated(MaxVariable::Currency as usize),
-                numeric_primary: csp.numeric_primary,
-                compressible_bytes,
-            }
-        });
+        let special_primaries = special_primaries.map_project(|csp, _| csp.validated());
 
         Ok(Collator {
             special_primaries,
@@ -748,50 +725,7 @@ impl CollatorBorrowed<'static> {
             LocaleSpecificDataHolder::try_new_unstable_internal(provider, prefs, options)?;
 
         let special_primaries = const {
-            &CollationSpecialPrimariesValidated {
-                last_primaries: zerovec::ZeroSlice::from_ule_slice(
-                    crate::provider::Baked::SINGLETON_COLLATION_SPECIAL_PRIMARIES_V1
-                        .last_primaries
-                        .as_slice()
-                        .as_ule_slice()
-                        .split_at(MaxVariable::Currency as usize)
-                        .0,
-                )
-                .as_zerovec(),
-                numeric_primary: crate::provider::Baked::SINGLETON_COLLATION_SPECIAL_PRIMARIES_V1
-                    .numeric_primary,
-                compressible_bytes: {
-                    const C: &[<u16 as zerovec::ule::AsULE>::ULE] =
-                        crate::provider::Baked::SINGLETON_COLLATION_SPECIAL_PRIMARIES_V1
-                            .last_primaries
-                            .as_slice()
-                            .as_ule_slice();
-                    if C.len() == MaxVariable::Currency as usize + 16 {
-                        let i = MaxVariable::Currency as usize;
-                        #[allow(clippy::indexing_slicing)] // protected, const
-                        &[
-                            C[i],
-                            C[i + 1],
-                            C[i + 2],
-                            C[i + 3],
-                            C[i + 4],
-                            C[i + 5],
-                            C[i + 6],
-                            C[i + 7],
-                            C[i + 8],
-                            C[i + 9],
-                            C[i + 10],
-                            C[i + 11],
-                            C[i + 12],
-                            C[i + 13],
-                            C[i + 14],
-                            C[i + 15],
-                        ]
-                    } else {
-                        CollationSpecialPrimariesValidated::HARDCODED_COMPRESSIBLE_BYTES_FALLBACK
-                    }
-                },
-            }
+            &crate::provider::Baked::SINGLETON_COLLATION_SPECIAL_PRIMARIES_V1.const_validated()
         };
 
         // Attribute belongs closer to `unwrap`, but

components/collator/src/provider.rs

@@ -649,8 +649,8 @@ pub(crate) struct CollationSpecialPrimariesValidated<'data> {
     pub compressible_bytes: &'data [<u16 as AsULE>::ULE; 16],
 }
 
-impl CollationSpecialPrimariesValidated<'static> {
-    pub(crate) const HARDCODED_COMPRESSIBLE_BYTES_FALLBACK: &'static [<u16 as AsULE>::ULE; 16] = &[
+impl<'a> CollationSpecialPrimaries<'a> {
+    const HARDCODED_COMPRESSIBLE_BYTES_FALLBACK: &'static [<u16 as AsULE>::ULE; 16] = &[
         <u16 as AsULE>::ULE::from_unsigned(0b0000_0000_0000_0000),
         <u16 as AsULE>::ULE::from_unsigned(0b0000_0000_0000_0000),
         <u16 as AsULE>::ULE::from_unsigned(0b0000_0000_0000_0000),
@@ -668,6 +668,63 @@ impl CollationSpecialPrimariesValidated<'static> {
         <u16 as AsULE>::ULE::from_unsigned(0b0000_0000_0000_0000),
         <u16 as AsULE>::ULE::from_unsigned(0b0100_0000_0000_0000),
     ];
+
+    pub(crate) fn validated(self) -> CollationSpecialPrimariesValidated<'a> {
+        let (last_primaries, compressible_bytes) =
+            if let Some(borrowed) = self.last_primaries.as_maybe_borrowed() {
+                let (l, c) = borrowed
+                    .as_ule_slice()
+                    // by invariant
+                    .split_at(MaxVariable::Currency as usize);
+                (
+                    l,
+                    c.try_into()
+                        .unwrap_or(Self::HARDCODED_COMPRESSIBLE_BYTES_FALLBACK),
+                )
+            } else {
+                (
+                    self.last_primaries.as_slice().as_ule_slice(),
+                    Self::HARDCODED_COMPRESSIBLE_BYTES_FALLBACK,
+                )
+            };
+
+        let last_primaries_truncate_len = last_primaries.len();
+        CollationSpecialPrimariesValidated {
+            last_primaries: self.last_primaries.truncated(last_primaries_truncate_len),
+            numeric_primary: self.numeric_primary,
+            compressible_bytes,
+        }
+    }
+
+    pub(crate) const fn const_validated(&'static self) -> CollationSpecialPrimariesValidated<'a> {
+        let borrowed = self.last_primaries.as_slice();
+        let (last_primaries, compressible_bytes) = borrowed
+            .as_ule_slice()
+            // by invariant
+            .split_at(MaxVariable::Currency as usize);
+        // TODO: use c.as_array() on MSRV 1.93
+        let compressible_bytes = if compressible_bytes.len() == 16 {
+            unsafe { &*(compressible_bytes.as_ptr() as *const [<u16 as AsULE>::ULE; 16]) }
+        } else {
+            Self::HARDCODED_COMPRESSIBLE_BYTES_FALLBACK
+        };
+
+        CollationSpecialPrimariesValidated {
+            last_primaries: ZeroSlice::from_ule_slice(last_primaries).as_zerovec(),
+            numeric_primary: self.numeric_primary,
+            compressible_bytes,
+        }
+    }
+}
+
+#[test]
+fn compressible_bytes() {
+    assert_eq!(
+        Baked::SINGLETON_COLLATION_SPECIAL_PRIMARIES_V1
+            .clone()
+            .validated(),
+        Baked::SINGLETON_COLLATION_SPECIAL_PRIMARIES_V1.const_validated(),
+    );
 }
 
 icu_provider::data_struct!(