Remove limb_width32 and limb_width64 features

Moved dispatch directly into the type system.

src/lexical/math.rs

@@ -6,7 +6,6 @@
 //! buffers, so for a `vec![0, 1, 2, 3]`, `3` is the most significant limb,
 //! and `0` is the least significant limb.
 
-use super::large_powers;
 use super::num::*;
 use super::small_powers::*;
 use alloc::vec::Vec;
@@ -36,31 +35,48 @@ use core::{cmp, iter, mem};
 //  requiring software emulation.
 //      sparc64 (`UMUL` only supported double-word arguments).
 
-// 32-BIT LIMB
-#[cfg(limb_width_32)]
-pub type Limb = u32;
-
-#[cfg(limb_width_32)]
-pub const POW5_LIMB: &[Limb] = &POW5_32;
-
-#[cfg(limb_width_32)]
-pub const POW10_LIMB: &[Limb] = &POW10_32;
+#[doc(hidden)]
+pub trait LimbConfig {
+    type Limb: 'static;
+    type Wide: 'static;
+    const POW5_LIMB: &'static [Self::Limb];
+    const POW10_LIMB: &'static [Self::Limb];
+    const LARGE_POWERS: &'static [&'static [Self::Limb]];
+}
 
-#[cfg(limb_width_32)]
-type Wide = u64;
+// 32-BIT LIMB
+#[doc(hidden)]
+pub struct LimbConfig32;
+
+impl LimbConfig for LimbConfig32 {
+    type Limb = u32;
+    type Wide = u64;
+    const POW5_LIMB: &'static [Self::Limb] = &POW5_32;
+    const POW10_LIMB: &'static [Self::Limb] = &POW10_32;
+    const LARGE_POWERS: &'static [&'static [Self::Limb]] = &super::large_powers32::POW5;
+}
 
 // 64-BIT LIMB
-#[cfg(limb_width_64)]
-pub type Limb = u64;
-
-#[cfg(limb_width_64)]
-pub const POW5_LIMB: &[Limb] = &POW5_64;
+#[doc(hidden)]
+pub struct LimbConfig64;
+impl LimbConfig for LimbConfig64 {
+    type Limb = u64;
+    type Wide = u128;
+    const POW5_LIMB: &'static [Self::Limb] = &POW5_64;
+    const POW10_LIMB: &'static [Self::Limb] = &POW10_64;
+    const LARGE_POWERS: &'static [&'static [Self::Limb]] = &super::large_powers64::POW5;
+}
 
-#[cfg(limb_width_64)]
-pub const POW10_LIMB: &[Limb] = &POW10_64;
+#[cfg(any(target_arch = "aarch64", target_arch = "mips64", target_arch = "powerpc64", target_arch = x86_64))]
+type PlatformLimbConfig = LimbConfig64;
+#[cfg(not(any(target_arch = "aarch64", target_arch = "mips64", target_arch = "powerpc64", target_arch = x86_64)))]
+type PlatformLimbConfig = LimbConfig32;
 
-#[cfg(limb_width_64)]
-type Wide = u128;
+pub type Limb = <PlatformLimbConfig as LimbConfig>::Limb;
+type Wide = <PlatformLimbConfig as LimbConfig>::Wide;
+pub const POW5_LIMB: &[Limb] = PlatformLimbConfig::POW5_LIMB;
+pub const POW10_LIMB: &[Limb] = PlatformLimbConfig::POW10_LIMB;
+const LARGE_POWERS: &'static [&'static [Limb]] = PlatformLimbConfig::LARGE_POWERS;
 
 /// Cast to limb type.
 #[inline]
@@ -391,7 +407,7 @@ mod small {
         use super::large::KARATSUBA_CUTOFF;
 
         let small_powers = POW5_LIMB;
-        let large_powers = large_powers::POW5;
+        let large_powers = LARGE_POWERS;
 
         if n == 0 {
             // No exponent, just return.

src/lexical/mod.rs

@@ -20,19 +20,14 @@ mod digit;
 mod errors;
 pub(crate) mod exponent;
 pub(crate) mod float;
-mod large_powers;
+mod large_powers32;
+mod large_powers64;
 pub(crate) mod math;
 pub(crate) mod num;
 pub(crate) mod parse;
 pub(crate) mod rounding;
 mod shift;
 mod small_powers;
 
-#[cfg(limb_width_32)]
-mod large_powers32;
-
-#[cfg(limb_width_64)]
-mod large_powers64;
-
 // API
 pub use self::parse::{parse_concise_float, parse_truncated_float};

src/lexical/small_powers.rs

@@ -3,19 +3,16 @@
 //! Pre-computed small powers.
 
 // 32 BIT
-#[cfg(limb_width_32)]
 pub(crate) const POW5_32: [u32; 14] = [
     1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125, 244140625,
     1220703125,
 ];
 
-#[cfg(limb_width_32)]
 pub(crate) const POW10_32: [u32; 10] = [
     1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
 ];
 
 // 64 BIT
-#[cfg(limb_width_64)]
 pub(crate) const POW5_64: [u64; 28] = [
     1,
     5,