Define 32-bit-shift cfgs in one place and disable it for wasm32

Apparently wasm32 support 64-bit shift.

Author: oxalica

library/core/src/str/validations.rs

@@ -2,6 +2,7 @@
 
 use super::Utf8Error;
 use crate::intrinsics::{const_eval_select, unlikely};
+use crate::mem;
 
 /// Returns the initial codepoint accumulator for the first byte.
 /// The first byte is special, only want bottom 5 bits for width 2, 4 bits
@@ -163,6 +164,13 @@ const ST_ERROR: u32 = 0 * BITS_PER_STATE as u32;
 #[allow(clippy::all)]
 const ST_ACCEPT: u32 = 1 * BITS_PER_STATE as u32;
 
+/// Platforms that does not have efficient 64-bit shift and should use 32-bit shift fallback.
+const USE_SHIFT32: bool = cfg!(all(
+    any(target_pointer_width = "16", target_pointer_width = "32"),
+    // WASM32 supports 64-bit shift.
+    not(target_arch = "wasm32"),
+));
+
 // After storing STATE_CNT * BITS_PER_STATE = 54bits on 64-bit platform, or (STATE_CNT - 5)
 // * BITS_PER_STATE = 24bits on 32-bit platform, we still have some high bits left.
 // They will never be used via state transition.
@@ -218,13 +226,12 @@ static TRANS_TABLE: [u64; 256] = {
 
         // On platforms without 64-bit shift, align states 5..10 to 32-bit boundary.
         // See docs above for details.
-        let need_align = cfg!(any(target_pointer_width = "16", target_pointer_width = "32"));
         let mut bits = 0u64;
         let mut j = 0;
         while j < to.len() {
             let to_off =
-                to[j] * BITS_PER_STATE as u64 + if need_align && to[j] >= 5 { 2 } else { 0 };
-            let off = j as u32 * BITS_PER_STATE + if need_align && j >= 5 { 2 } else { 0 };
+                to[j] * BITS_PER_STATE as u64 + if USE_SHIFT32 && to[j] >= 5 { 2 } else { 0 };
+            let off = j as u32 * BITS_PER_STATE + if USE_SHIFT32 && j >= 5 { 2 } else { 0 };
             bits |= to_off << off;
             j += 1;
         }
@@ -244,20 +251,17 @@ static TRANS_TABLE: [u64; 256] = {
     table
 };
 
-#[cfg(not(any(target_pointer_width = "16", target_pointer_width = "32")))]
 #[inline(always)]
 const fn next_state(st: u32, byte: u8) -> u32 {
-    TRANS_TABLE[byte as usize].wrapping_shr(st as _) as _
-}
-
-#[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))]
-#[inline(always)]
-const fn next_state(st: u32, byte: u8) -> u32 {
-    // SAFETY: `u64` is more aligned than `u32`, and has the same repr as `[u32; 2]`.
-    let [lo, hi] = unsafe { crate::mem::transmute::<u64, [u32; 2]>(TRANS_TABLE[byte as usize]) };
-    #[cfg(target_endian = "big")]
-    let (lo, hi) = (hi, lo);
-    if st & 32 == 0 { lo } else { hi }.wrapping_shr(st)
+    if USE_SHIFT32 {
+        // SAFETY: `u64` is more aligned than `u32`, and has the same repr as `[u32; 2]`.
+        let [lo, hi] = unsafe { mem::transmute::<u64, [u32; 2]>(TRANS_TABLE[byte as usize]) };
+        #[cfg(target_endian = "big")]
+        let (lo, hi) = (hi, lo);
+        if st & 32 == 0 { lo } else { hi }.wrapping_shr(st)
+    } else {
+        TRANS_TABLE[byte as usize].wrapping_shr(st as _) as _
+    }
 }
 
 /// Check if `byte` is a valid UTF-8 first byte, assuming it must be a valid first or