Add #[inline] to all hot-path functions for cross-crate optimization

Without #[inline], Rust cannot inline functions across crate boundaries,
forcing all calls through opaque function pointers. This prevented constant
propagation, register allocation across call boundaries, and further
compiler optimizations for downstream users.

Benchmark results (Apple M3 Pro):
- format: 102 ns → 63 ns (-38%)
- parse:  805 ns → 738 ns (-8%)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: gfx

src/lib.rs

@@ -46,42 +46,52 @@ fn unround(x: f64) -> Unrounded {
 
 #[allow(dead_code, clippy::many_single_char_names)]
 impl Unrounded {
+    #[inline]
     fn floor(self) -> u64 {
         self.0 >> 2
     }
+    #[inline]
     fn round_half_down(self) -> u64 {
         (self.0 + 1) >> 2
     }
+    #[inline]
     fn round(self) -> u64 {
         (self.0 + 1 + ((self.0 >> 2) & 1)) >> 2
     }
+    #[inline]
     fn round_half_up(self) -> u64 {
         (self.0 + 2) >> 2
     }
+    #[inline]
     fn ceil(self) -> u64 {
         (self.0 + 3) >> 2
     }
+    #[inline]
     fn nudge(self, delta: i32) -> Unrounded {
         Unrounded(self.0.wrapping_add(delta as u64))
     }
 
+    #[inline]
     fn div(self, d: u64) -> Unrounded {
         let x = self.0;
         Unrounded((x / d) | (self.0 & 1) | u64::from(!x.is_multiple_of(d)))
     }
 
+    #[inline]
     fn rsh(self, s: u32) -> Unrounded {
         Unrounded((self.0 >> s) | (self.0 & 1) | u64::from(self.0 & ((1u64 << s) - 1) != 0))
     }
 }
 
 /// `log10_pow2(x)` returns `floor(log10(2**x))` = `floor(x * log10(2))`.
+#[inline]
 fn log10_pow2(x: i32) -> i32 {
     // log10(2) ~ 0.30102999566 ~ 78913 / 2^18
     (x * 78913) >> 18
 }
 
 /// `log2_pow10(x)` returns `floor(log2(10**x))` = `floor(x * log2(10))`.
+#[inline]
 fn log2_pow10(x: i32) -> i32 {
     // log2(10) ~ 3.32192809489 ~ 108853 / 2^15
     (x * 108_853) >> 15
@@ -114,6 +124,7 @@ const UINT64_POW10: [u64; 20] = [
 /// `unpack64` returns (m, e) such that `f = m * 2**e`.
 /// The caller is expected to have handled 0, NaN, and +/-Inf already.
 /// To unpack an `f32`, use `unpack64(f as f64)`.
+#[inline]
 #[allow(clippy::many_single_char_names)]
 fn unpack64(f: f64) -> (u64, i32) {
     const SHIFT: u32 = 64 - 53; // 11
@@ -133,6 +144,7 @@ fn unpack64(f: f64) -> (u64, i32) {
 /// `pack64` takes (m, e) and returns `f = m * 2**e`.
 /// It assumes the caller has provided a 53-bit mantissa m
 /// and an exponent that is in range for the mantissa.
+#[inline]
 fn pack64(m: u64, e: i32) -> f64 {
     if m & (1u64 << 52) == 0 {
         return f64::from_bits(m);
@@ -141,12 +153,14 @@ fn pack64(m: u64, e: i32) -> f64 {
 }
 
 /// `unmin` returns the minimum unrounded that rounds to x.
+#[inline]
 fn unmin(x: u64) -> Unrounded {
     Unrounded((x << 2) - 2)
 }
 
 /// `prescale` returns the scaling constants for (e, p).
 /// `lp` must be `log2_pow10(p)`.
+#[inline]
 fn prescale(e: i32, p: i32, lp: i32) -> Scaler {
     Scaler {
         pm: POW10_TAB[(p - POW10_MIN) as usize],
@@ -157,6 +171,7 @@ fn prescale(e: i32, p: i32, lp: i32) -> Scaler {
 /// `uscale` returns `unround(x * 2**e * 10**p)`.
 /// The caller should pass `c = prescale(e, p, log2_pow10(p))`
 /// and should have left-justified x so its high bit is set.
+#[inline]
 fn uscale(x: u64, c: Scaler) -> Unrounded {
     let r = u128::from(x) * u128::from(c.pm.hi);
     let mut hi = (r >> 64) as u64;
@@ -178,6 +193,7 @@ fn uscale(x: u64, c: Scaler) -> Unrounded {
 ///
 /// Panics if `n > 18`.
 #[must_use]
+#[inline]
 #[allow(clippy::many_single_char_names)]
 pub fn fixed_width(f: f64, n: i32) -> (u64, i32) {
     assert!(n <= 18, "too many digits");
@@ -200,6 +216,7 @@ pub fn fixed_width(f: f64, n: i32) -> (u64, i32) {
 ///
 /// Panics if `d > 10_000_000_000_000_000_000` (more than 19 digits).
 #[must_use]
+#[inline]
 #[allow(clippy::many_single_char_names)]
 pub fn parse(d: u64, p: i32) -> f64 {
     assert!(d <= 10_000_000_000_000_000_000, "too many digits");
@@ -223,6 +240,7 @@ pub fn parse(d: u64, p: i32) -> f64 {
 /// Parses a decimal string and returns the nearest f64.
 /// Returns `None` if the input is malformed.
 #[must_use]
+#[inline]
 pub fn parse_text(s: &[u8]) -> Option<f64> {
     fn is_digit(c: u8) -> bool {
         c.wrapping_sub(b'0') <= 9
@@ -290,6 +308,7 @@ pub fn parse_text(s: &[u8]) -> Option<f64> {
 /// using as few digits as possible that will still round trip
 /// back to the original f64.
 #[must_use]
+#[inline]
 #[allow(clippy::many_single_char_names)]
 pub fn short(f: f64) -> (u64, i32) {
     const MIN_EXP: i32 = -1085;
@@ -330,13 +349,15 @@ pub fn short(f: f64) -> (u64, i32) {
 
 /// Computes the skewed footprint of `m * 2**e`,
 /// which is `floor(log10(3/4 * 2**e))` = `floor(e*log10(2) - log10(4/3))`.
+#[inline]
 fn skewed(e: i32) -> i32 {
     (e * 631_305 - 261_663) >> 21
 }
 
 /// Removes trailing zeros from `x * 10**p`.
 /// If x ends in k zeros, returns `(x/10**k, p+k)`.
 /// Assumes that x ends in at most 16 zeros.
+#[inline]
 #[allow(clippy::unreadable_literal)]
 fn trim_zeros(x: u64, p: i32) -> (u64, i32) {
     const INV5P8: u64 = 0xc767074b22e90e21; // inverse of 5**8
@@ -397,6 +418,7 @@ const I2A: &[u8] = b"\
 /// Formats the decimal representation of u into a.
 /// The caller is responsible for ensuring that a is big enough to hold u.
 /// If a is too big, leading zeros will be filled in as needed.
+#[inline]
 fn format_base10(a: &mut [u8], mut u: u64) {
     let mut nd = a.len();
     while nd >= 8 {
@@ -447,6 +469,7 @@ fn format_base10(a: &mut [u8], mut u: u64) {
 /// The caller must pass nd set to the number of digits in d.
 /// Returns the number of bytes written to s.
 #[must_use]
+#[inline]
 pub fn fmt_float(s: &mut [u8], d: u64, p: i32, nd: i32) -> usize {
     let nd = nd as usize;
     // Put digits into s, leaving room for decimal point.
@@ -483,6 +506,7 @@ pub fn fmt_float(s: &mut [u8], d: u64, p: i32, nd: i32) -> usize {
 
 /// Returns the number of decimal digits in d.
 #[must_use]
+#[inline]
 pub fn digits(d: u64) -> i32 {
     let nd = log10_pow2(64 - d.leading_zeros() as i32);
     nd + i32::from(d >= UINT64_POW10[nd as usize])