From 1f209c39598fa3adb567ff9f9de76769aa6ac9f4 Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Mon, 10 May 2021 21:56:27 +0100
Subject: [PATCH 01/15] faster parsing when not possible to overflow

---
 core/src/num/mod.rs | 85 ++++++++++++++++++++++++++-------------------
 1 file changed, 50 insertions(+), 35 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index dca8ffa4e..5fd697fd4 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -970,12 +970,14 @@ pub enum FpCategory {
 
 #[doc(hidden)]
 trait FromStrRadixHelper: PartialOrd + Copy {
-    fn min_value() -> Self;
-    fn max_value() -> Self;
+    const MIN: Self;
     fn from_u32(u: u32) -> Self;
     fn checked_mul(&self, other: u32) -> Option<Self>;
     fn checked_sub(&self, other: u32) -> Option<Self>;
     fn checked_add(&self, other: u32) -> Option<Self>;
+    unsafe fn unchecked_mul(&self, other: u32) -> Self;
+    unsafe fn unchecked_sub(&self, other: u32) -> Self;
+    unsafe fn unchecked_add(&self, other: u32) -> Self;
 }
 
 macro_rules! from_str_radix_int_impl {
@@ -993,10 +995,7 @@ from_str_radix_int_impl! { isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 }
 
 macro_rules! doit {
     ($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
-        #[inline]
-        fn min_value() -> Self { Self::MIN }
-        #[inline]
-        fn max_value() -> Self { Self::MAX }
+        const MIN: Self = Self::MIN;
         #[inline]
         fn from_u32(u: u32) -> Self { u as Self }
         #[inline]
@@ -1011,6 +1010,27 @@ macro_rules! doit {
         fn checked_add(&self, other: u32) -> Option<Self> {
             Self::checked_add(*self, other as Self)
         }
+        #[inline]
+        unsafe fn unchecked_mul(&self, other: u32) -> Self {
+            // SAFETY:  Conditions of `Self::unchecked_mul` must be upheld by the caller.
+            unsafe {
+                Self::unchecked_mul(*self, other as Self)
+            }
+        }
+        #[inline]
+        unsafe fn unchecked_sub(&self, other: u32) -> Self {
+            // SAFETY:  Conditions of `Self::unchecked_sub` must be upheld by the caller.
+            unsafe {
+                Self::unchecked_sub(*self, other as Self)
+            }
+        }
+        #[inline]
+        unsafe fn unchecked_add(&self, other: u32) -> Self {
+            // SAFETY: Conditions of `Self::unchecked_add` must be upheld by the caller.
+            unsafe {
+                Self::unchecked_add(*self, other as Self)
+            }
+        }
     })*)
 }
 doit! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
@@ -1029,7 +1049,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         return Err(PIE { kind: Empty });
     }
 
-    let is_signed_ty = T::from_u32(0) > T::min_value();
+    let is_signed_ty = T::from_u32(0) > T::MIN;
 
     // all valid digits are ascii, so we will just iterate over the utf8 bytes
     // and cast them to chars. .to_digit() will safely return None for anything
@@ -1047,37 +1067,32 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
     };
 
     let mut result = T::from_u32(0);
-    if is_positive {
-        // The number is positive
-        for &c in digits {
-            let x = match (c as char).to_digit(radix) {
-                Some(x) => x,
-                None => return Err(PIE { kind: InvalidDigit }),
-            };
-            result = match result.checked_mul(radix) {
-                Some(result) => result,
-                None => return Err(PIE { kind: PosOverflow }),
-            };
-            result = match result.checked_add(x) {
-                Some(result) => result,
-                None => return Err(PIE { kind: PosOverflow }),
-            };
+
+    if radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize {
+        // SAFETY: Consider the highest radix of 16:
+        // `u8::MAX` is `ff` (2 characters), `u16::MAX` is `ffff` (4 characters)
+        // We can be sure that any src len of 2 would fit in a u8 so we don't need
+        // to check for overflow.
+        unsafe {
+            let unchecked_additive_op =
+                if is_positive { T::unchecked_add } else { T::unchecked_sub };
+
+            for &c in digits {
+                result = result.unchecked_mul(radix);
+                let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
+                result = unchecked_additive_op(&result, x);
+            }
         }
     } else {
-        // The number is negative
+        let additive_op = if is_positive { T::checked_add } else { T::checked_sub };
+        let overflow_err = || PIE { kind: if is_positive { PosOverflow } else { NegOverflow } };
+
         for &c in digits {
-            let x = match (c as char).to_digit(radix) {
-                Some(x) => x,
-                None => return Err(PIE { kind: InvalidDigit }),
-            };
-            result = match result.checked_mul(radix) {
-                Some(result) => result,
-                None => return Err(PIE { kind: NegOverflow }),
-            };
-            result = match result.checked_sub(x) {
-                Some(result) => result,
-                None => return Err(PIE { kind: NegOverflow }),
-            };
+            let mul = result.checked_mul(radix);
+            let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
+            // multiply done early for performance reasons.
+            result = mul.ok_or_else(overflow_err)?;
+            result = additive_op(&result, x).ok_or_else(overflow_err)?;
         }
     }
     Ok(result)

From 74ca9ac3e5a83cb7769b124539966327b4623ec9 Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Tue, 18 May 2021 08:51:20 +0100
Subject: [PATCH 02/15] add likely and clearer comments

---
 core/src/num/mod.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 5fd697fd4..194193348 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1068,8 +1068,13 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
 
     let mut result = T::from_u32(0);
 
-    if radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize {
-        // SAFETY: Consider the highest radix of 16:
+    if intrinsics::likely(
+        radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize,
+    ) {
+        // SAFETY: We can take this fast path when `radix.pow(digits.len()) - 1 <= T::MAX`
+        // but the condition above is a faster (conservative) approximation of this.
+        //
+        // Consider the highest radix of 16:
         // `u8::MAX` is `ff` (2 characters), `u16::MAX` is `ffff` (4 characters)
         // We can be sure that any src len of 2 would fit in a u8 so we don't need
         // to check for overflow.
@@ -1088,9 +1093,14 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         let overflow_err = || PIE { kind: if is_positive { PosOverflow } else { NegOverflow } };
 
         for &c in digits {
+            // When `radix` is passed in as a literal, rather than doing a slow `imul`
+            // then the compiler can use a shift if `radix` is a power of 2.
+            // (*10 can also be turned into *8 + *2).
+            // When the compiler can't use these optimisations,
+            // there is a latency of several cycles so doing the
+            // multiply before we need to use the result helps.
             let mul = result.checked_mul(radix);
             let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
-            // multiply done early for performance reasons.
             result = mul.ok_or_else(overflow_err)?;
             result = additive_op(&result, x).ok_or_else(overflow_err)?;
         }

From c59ec308c2aea3cbbd00e2930ee8ab5710766220 Mon Sep 17 00:00:00 2001
From: Squirrel <gilescope@gmail.com>
Date: Tue, 18 May 2021 18:22:04 +0100
Subject: [PATCH 03/15] Update library/core/src/num/mod.rs

Co-authored-by: LingMan <LingMan@users.noreply.github.com>
---
 core/src/num/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 194193348..a833f4025 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1094,8 +1094,8 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
 
         for &c in digits {
             // When `radix` is passed in as a literal, rather than doing a slow `imul`
-            // then the compiler can use a shift if `radix` is a power of 2.
-            // (*10 can also be turned into *8 + *2).
+            // the compiler can use shifts if `radix` can be expressed as a
+            // sum of powers of 2 (x*10 can be written as x*8 + x*2).
             // When the compiler can't use these optimisations,
             // there is a latency of several cycles so doing the
             // multiply before we need to use the result helps.

From 3dcf9eec861c316942787df73f8dfb6e88dce758 Mon Sep 17 00:00:00 2001
From: Squirrel <gilescope@gmail.com>
Date: Tue, 18 May 2021 18:22:21 +0100
Subject: [PATCH 04/15] Update library/core/src/num/mod.rs

Co-authored-by: LingMan <LingMan@users.noreply.github.com>
---
 core/src/num/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index a833f4025..9cd278e75 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1097,8 +1097,8 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
             // the compiler can use shifts if `radix` can be expressed as a
             // sum of powers of 2 (x*10 can be written as x*8 + x*2).
             // When the compiler can't use these optimisations,
-            // there is a latency of several cycles so doing the
-            // multiply before we need to use the result helps.
+            // the latency of the multiplication can be hidden by issuing it
+            // before the result is needed.
             let mul = result.checked_mul(radix);
             let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
             result = mul.ok_or_else(overflow_err)?;

From 80bab02c5ec32fce5afbc5581b25a0316d0af7bc Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Tue, 18 May 2021 19:00:33 +0100
Subject: [PATCH 05/15] removed likely

---
 core/src/num/mod.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 9cd278e75..c263f4de0 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1068,9 +1068,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
 
     let mut result = T::from_u32(0);
 
-    if intrinsics::likely(
-        radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize,
-    ) {
+    if radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize {
         // SAFETY: We can take this fast path when `radix.pow(digits.len()) - 1 <= T::MAX`
         // but the condition above is a faster (conservative) approximation of this.
         //

From b57464389b1c7e83324d9bb7bc4aca59d7110f9f Mon Sep 17 00:00:00 2001
From: Squirrel <gilescope@gmail.com>
Date: Wed, 19 May 2021 08:33:05 +0100
Subject: [PATCH 06/15] Update library/core/src/num/mod.rs

Co-authored-by: Ivan Tham <pickfire@riseup.net>
---
 core/src/num/mod.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index c263f4de0..69d67486e 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1096,7 +1096,11 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
             // sum of powers of 2 (x*10 can be written as x*8 + x*2).
             // When the compiler can't use these optimisations,
             // the latency of the multiplication can be hidden by issuing it
-            // before the result is needed.
+            // before the result is needed to improve performance on
+            // modern out-of-order CPU as multiplication here is slower
+            // than the other instructions, we can get the end result faster
+            // doing multiplication first and let the CPU spends other cycles
+            // doing other computation and get multiplication result later.
             let mul = result.checked_mul(radix);
             let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
             result = mul.ok_or_else(overflow_err)?;

From a27c01ceca6f59a39ee88986e7df1ce4bd775833 Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Thu, 27 May 2021 08:31:26 +0100
Subject: [PATCH 07/15] Better explanation

---
 core/src/num/mod.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 69d67486e..e13a3209b 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1069,13 +1069,14 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
     let mut result = T::from_u32(0);
 
     if radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize {
-        // SAFETY: We can take this fast path when `radix.pow(digits.len()) - 1 <= T::MAX`
-        // but the condition above is a faster (conservative) approximation of this.
+        // SAFETY: If the len of the str is short compared to the range of the type
+        // we are parsing into, then we can be certain that an overflow will not occur.
+        // This bound is when `radix.pow(digits.len()) - 1 <= T::MAX` but the condition
+        // above is a faster (conservative) approximation of this.
         //
-        // Consider the highest radix of 16:
-        // `u8::MAX` is `ff` (2 characters), `u16::MAX` is `ffff` (4 characters)
-        // We can be sure that any src len of 2 would fit in a u8 so we don't need
-        // to check for overflow.
+        // Consider radix 16 as it has the most chance of overflow per digit:
+        // `u8::MAX` is `ff` - any str of len 2 is guaranteed to not overflow.
+        // `i8::MAX` is `7f` - only a str of len 1 is guaranteed to not overflow.
         unsafe {
             let unchecked_additive_op =
                 if is_positive { T::unchecked_add } else { T::unchecked_sub };

From cf72bdcddcabd6bae11027ba9e4bfdd999418fb7 Mon Sep 17 00:00:00 2001
From: Squirrel <gilescope@gmail.com>
Date: Sat, 19 Jun 2021 14:03:24 +0100
Subject: [PATCH 08/15] Update library/core/src/num/mod.rs

Co-authored-by: LingMan <LingMan@users.noreply.github.com>
---
 core/src/num/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index e13a3209b..a398fe4a8 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1074,7 +1074,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         // This bound is when `radix.pow(digits.len()) - 1 <= T::MAX` but the condition
         // above is a faster (conservative) approximation of this.
         //
-        // Consider radix 16 as it has the most chance of overflow per digit:
+        // Consider radix 16 as it has the highest information density per digit and will thus overflow the earliest:
         // `u8::MAX` is `ff` - any str of len 2 is guaranteed to not overflow.
         // `i8::MAX` is `7f` - only a str of len 1 is guaranteed to not overflow.
         unsafe {

From ce57820517e2b92be9ec6b7821ebd8cbf690fbb0 Mon Sep 17 00:00:00 2001
From: gilescope <gilescope@gmail.com>
Date: Sat, 26 Mar 2022 14:53:56 +0000
Subject: [PATCH 09/15] Using macro to avoid performance hit (thanks LingMan)

---
 core/src/num/mod.rs | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index a398fe4a8..4a73329e7 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1078,14 +1078,20 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         // `u8::MAX` is `ff` - any str of len 2 is guaranteed to not overflow.
         // `i8::MAX` is `7f` - only a str of len 1 is guaranteed to not overflow.
         unsafe {
-            let unchecked_additive_op =
-                if is_positive { T::unchecked_add } else { T::unchecked_sub };
-
-            for &c in digits {
-                result = result.unchecked_mul(radix);
-                let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
-                result = unchecked_additive_op(&result, x);
+            macro_rules! run_loop {
+                ($unchecked_additive_op:ident) => {
+                    for &c in digits {
+                        result = result.unchecked_mul(radix);
+                        let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
+                        result = T::$unchecked_additive_op(&result, x);
+                    }
+                };
             }
+            if is_positive {
+                run_loop!(unchecked_add)
+            } else {
+                run_loop!(unchecked_sub)
+            };
         }
     } else {
         let additive_op = if is_positive { T::checked_add } else { T::checked_sub };

From 952a6049e3f693512f150268606275ccc6992a3b Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Sat, 2 Apr 2022 10:28:33 +0100
Subject: [PATCH 10/15] incorporating feedback

---
 core/src/num/mod.rs | 76 +++++++++++++++++++++++++--------------------
 1 file changed, 42 insertions(+), 34 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 4a73329e7..5eb7b9096 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -975,9 +975,9 @@ trait FromStrRadixHelper: PartialOrd + Copy {
     fn checked_mul(&self, other: u32) -> Option<Self>;
     fn checked_sub(&self, other: u32) -> Option<Self>;
     fn checked_add(&self, other: u32) -> Option<Self>;
-    unsafe fn unchecked_mul(&self, other: u32) -> Self;
-    unsafe fn unchecked_sub(&self, other: u32) -> Self;
-    unsafe fn unchecked_add(&self, other: u32) -> Self;
+    unsafe fn unchecked_mul(self, other: u32) -> Self;
+    unsafe fn unchecked_sub(self, other: u32) -> Self;
+    unsafe fn unchecked_add(self, other: u32) -> Self;
 }
 
 macro_rules! from_str_radix_int_impl {
@@ -993,7 +993,7 @@ macro_rules! from_str_radix_int_impl {
 }
 from_str_radix_int_impl! { isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 }
 
-macro_rules! doit {
+macro_rules! impl_helper_for {
     ($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
         const MIN: Self = Self::MIN;
         #[inline]
@@ -1011,29 +1011,29 @@ macro_rules! doit {
             Self::checked_add(*self, other as Self)
         }
         #[inline]
-        unsafe fn unchecked_mul(&self, other: u32) -> Self {
+        unsafe fn unchecked_mul(self, other: u32) -> Self {
             // SAFETY:  Conditions of `Self::unchecked_mul` must be upheld by the caller.
             unsafe {
-                Self::unchecked_mul(*self, other as Self)
+                Self::unchecked_mul(self, other as Self)
             }
         }
         #[inline]
-        unsafe fn unchecked_sub(&self, other: u32) -> Self {
+        unsafe fn unchecked_sub(self, other: u32) -> Self {
             // SAFETY:  Conditions of `Self::unchecked_sub` must be upheld by the caller.
             unsafe {
-                Self::unchecked_sub(*self, other as Self)
+                Self::unchecked_sub(self, other as Self)
             }
         }
         #[inline]
-        unsafe fn unchecked_add(&self, other: u32) -> Self {
+        unsafe fn unchecked_add(self, other: u32) -> Self {
             // SAFETY: Conditions of `Self::unchecked_add` must be upheld by the caller.
             unsafe {
-                Self::unchecked_add(*self, other as Self)
+                Self::unchecked_add(self, other as Self)
             }
         }
     })*)
 }
-doit! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
+impl_helper_for! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
 
 fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, ParseIntError> {
     use self::IntErrorKind::*;
@@ -1078,41 +1078,49 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         // `u8::MAX` is `ff` - any str of len 2 is guaranteed to not overflow.
         // `i8::MAX` is `7f` - only a str of len 1 is guaranteed to not overflow.
         unsafe {
-            macro_rules! run_loop {
+            macro_rules! run_unchecked_loop {
                 ($unchecked_additive_op:ident) => {
                     for &c in digits {
                         result = result.unchecked_mul(radix);
                         let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
-                        result = T::$unchecked_additive_op(&result, x);
+                        result = T::$unchecked_additive_op(result, x);
                     }
                 };
             }
             if is_positive {
-                run_loop!(unchecked_add)
+                run_unchecked_loop!(unchecked_add)
             } else {
-                run_loop!(unchecked_sub)
+                run_unchecked_loop!(unchecked_sub)
             };
         }
-    } else {
-        let additive_op = if is_positive { T::checked_add } else { T::checked_sub };
-        let overflow_err = || PIE { kind: if is_positive { PosOverflow } else { NegOverflow } };
-
-        for &c in digits {
-            // When `radix` is passed in as a literal, rather than doing a slow `imul`
-            // the compiler can use shifts if `radix` can be expressed as a
-            // sum of powers of 2 (x*10 can be written as x*8 + x*2).
-            // When the compiler can't use these optimisations,
-            // the latency of the multiplication can be hidden by issuing it
-            // before the result is needed to improve performance on
-            // modern out-of-order CPU as multiplication here is slower
-            // than the other instructions, we can get the end result faster
-            // doing multiplication first and let the CPU spends other cycles
-            // doing other computation and get multiplication result later.
-            let mul = result.checked_mul(radix);
-            let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
-            result = mul.ok_or_else(overflow_err)?;
-            result = additive_op(&result, x).ok_or_else(overflow_err)?;
+    } else {        
+        macro_rules! run_checked_loop {
+            ($checked_additive_op:ident, $overflow_err:ident) => {
+                for &c in digits {
+                    // When `radix` is passed in as a literal, rather than doing a slow `imul`
+                    // the compiler can use shifts if `radix` can be expressed as a
+                    // sum of powers of 2 (x*10 can be written as x*8 + x*2).
+                    // When the compiler can't use these optimisations,
+                    // the latency of the multiplication can be hidden by issuing it
+                    // before the result is needed to improve performance on
+                    // modern out-of-order CPU as multiplication here is slower
+                    // than the other instructions, we can get the end result faster
+                    // doing multiplication first and let the CPU spends other cycles
+                    // doing other computation and get multiplication result later.
+                    let mul = result.checked_mul(radix);
+                    let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
+                    result = mul.ok_or_else($overflow_err)?;
+                    result =  T::$checked_additive_op(&result, x).ok_or_else($overflow_err)?;
+                }
+            }
         }
+        if is_positive {
+            let overflow_err = || PIE { kind: PosOverflow };
+            run_checked_loop!(checked_add, overflow_err)
+        } else {
+            let overflow_err = || PIE { kind: NegOverflow };
+            run_checked_loop!(checked_sub, overflow_err)
+        };
     }
     Ok(result)
 }

From b88e6154da24f433c33188ee41c5c9c73f6e33f3 Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Sat, 2 Apr 2022 11:13:44 +0100
Subject: [PATCH 11/15] need guidence on testing

---
 core/src/num/mod.rs | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 5eb7b9096..12ab12d7e 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -1035,6 +1035,11 @@ macro_rules! impl_helper_for {
 }
 impl_helper_for! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
 
+#[inline(always)]
+pub(crate) fn can_not_overflow<T>(radix: u32, is_signed_ty: bool, digits:&[u8]) -> bool {
+    radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize
+}
+
 fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, ParseIntError> {
     use self::IntErrorKind::*;
     use self::ParseIntError as PIE;
@@ -1068,7 +1073,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
 
     let mut result = T::from_u32(0);
 
-    if radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize {
+    if can_not_overflow::<T>(radix, is_signed_ty, digits) {
         // SAFETY: If the len of the str is short compared to the range of the type
         // we are parsing into, then we can be certain that an overflow will not occur.
         // This bound is when `radix.pow(digits.len()) - 1 <= T::MAX` but the condition
@@ -1093,9 +1098,9 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
                 run_unchecked_loop!(unchecked_sub)
             };
         }
-    } else {        
+    } else {
         macro_rules! run_checked_loop {
-            ($checked_additive_op:ident, $overflow_err:ident) => {
+            ($checked_additive_op:ident, $overflow_err:expr) => {
                 for &c in digits {
                     // When `radix` is passed in as a literal, rather than doing a slow `imul`
                     // the compiler can use shifts if `radix` can be expressed as a
@@ -1110,17 +1115,23 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
                     let mul = result.checked_mul(radix);
                     let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
                     result = mul.ok_or_else($overflow_err)?;
-                    result =  T::$checked_additive_op(&result, x).ok_or_else($overflow_err)?;
+                    result = T::$checked_additive_op(&result, x).ok_or_else($overflow_err)?;
                 }
-            }
+            };
         }
         if is_positive {
-            let overflow_err = || PIE { kind: PosOverflow };
-            run_checked_loop!(checked_add, overflow_err)
+            run_checked_loop!(checked_add, || PIE { kind: PosOverflow })
         } else {
-            let overflow_err = || PIE { kind: NegOverflow };
-            run_checked_loop!(checked_sub, overflow_err)
+            run_checked_loop!(checked_sub, || PIE { kind: NegOverflow })
         };
     }
     Ok(result)
 }
+
+mod tests {
+    #[test]
+    fn test_can_not_overflow() {
+        assert_eq!(can_not_overflow::<i8>(10, true, "99".as_bytes()), true);
+        assert_eq!(can_not_overflow::<i8>(10, true, "129".as_bytes()), false);
+    }
+}
\ No newline at end of file

From 43b024453e5ae89c6412639eab0c707f2c9831ee Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Mon, 4 Apr 2022 15:53:53 +0100
Subject: [PATCH 12/15] from_u32(0) can just be default()

---
 core/src/num/mod.rs   | 25 +++++++++--------------
 core/tests/lib.rs     |  1 +
 core/tests/num/mod.rs | 47 ++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 57 insertions(+), 16 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 12ab12d7e..5bead39a3 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -969,9 +969,8 @@ pub enum FpCategory {
 }
 
 #[doc(hidden)]
-trait FromStrRadixHelper: PartialOrd + Copy {
+trait FromStrRadixHelper: PartialOrd + Copy + Default {
     const MIN: Self;
-    fn from_u32(u: u32) -> Self;
     fn checked_mul(&self, other: u32) -> Option<Self>;
     fn checked_sub(&self, other: u32) -> Option<Self>;
     fn checked_add(&self, other: u32) -> Option<Self>;
@@ -997,8 +996,6 @@ macro_rules! impl_helper_for {
     ($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
         const MIN: Self = Self::MIN;
         #[inline]
-        fn from_u32(u: u32) -> Self { u as Self }
-        #[inline]
         fn checked_mul(&self, other: u32) -> Option<Self> {
             Self::checked_mul(*self, other as Self)
         }
@@ -1035,8 +1032,14 @@ macro_rules! impl_helper_for {
 }
 impl_helper_for! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
 
+/// Determins if a string of text of that length of that radix could be guaranteed to be
+/// stored in the given type T.
+/// Note that if the radix is known to the compiler, it is just the check of digits.len that
+/// is done at runtime.
+#[doc(hidden)]
 #[inline(always)]
-pub(crate) fn can_not_overflow<T>(radix: u32, is_signed_ty: bool, digits:&[u8]) -> bool {
+#[unstable(issue = "none", feature = "std_internals")]
+pub fn can_not_overflow<T>(radix: u32, is_signed_ty: bool, digits: &[u8]) -> bool {
     radix <= 16 && digits.len() <= mem::size_of::<T>() * 2 - is_signed_ty as usize
 }
 
@@ -1054,7 +1057,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         return Err(PIE { kind: Empty });
     }
 
-    let is_signed_ty = T::from_u32(0) > T::MIN;
+    let is_signed_ty = T::default() > T::MIN;
 
     // all valid digits are ascii, so we will just iterate over the utf8 bytes
     // and cast them to chars. .to_digit() will safely return None for anything
@@ -1071,7 +1074,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         _ => (true, src),
     };
 
-    let mut result = T::from_u32(0);
+    let mut result = T::default();
 
     if can_not_overflow::<T>(radix, is_signed_ty, digits) {
         // SAFETY: If the len of the str is short compared to the range of the type
@@ -1127,11 +1130,3 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
     }
     Ok(result)
 }
-
-mod tests {
-    #[test]
-    fn test_can_not_overflow() {
-        assert_eq!(can_not_overflow::<i8>(10, true, "99".as_bytes()), true);
-        assert_eq!(can_not_overflow::<i8>(10, true, "129".as_bytes()), false);
-    }
-}
\ No newline at end of file
diff --git a/core/tests/lib.rs b/core/tests/lib.rs
index 5c861236e..bc2ab7489 100644
--- a/core/tests/lib.rs
+++ b/core/tests/lib.rs
@@ -55,6 +55,7 @@
 #![feature(numfmt)]
 #![feature(step_trait)]
 #![feature(str_internals)]
+#![feature(std_internals)]
 #![feature(test)]
 #![feature(trusted_len)]
 #![feature(try_blocks)]
diff --git a/core/tests/num/mod.rs b/core/tests/num/mod.rs
index 4f773a824..0abc88f21 100644
--- a/core/tests/num/mod.rs
+++ b/core/tests/num/mod.rs
@@ -2,7 +2,7 @@ use core::cmp::PartialEq;
 use core::convert::{TryFrom, TryInto};
 use core::fmt::Debug;
 use core::marker::Copy;
-use core::num::{IntErrorKind, ParseIntError, TryFromIntError};
+use core::num::{can_not_overflow, IntErrorKind, ParseIntError, TryFromIntError};
 use core::ops::{Add, Div, Mul, Rem, Sub};
 use core::option::Option;
 use core::option::Option::None;
@@ -120,6 +120,51 @@ fn test_int_from_str_overflow() {
     test_parse::<i64>("-9223372036854775809", Err(IntErrorKind::NegOverflow));
 }
 
+#[test]
+fn test_can_not_overflow() {
+    // Not currently in std lib (issue: #27728)
+    fn format_radix<T>(mut x: T, radix: T) -> String
+    where
+        T: std::ops::Rem<Output = T>,
+        T: std::ops::Div<Output = T>,
+        T: std::cmp::PartialEq,
+        T: std::default::Default,
+        T: Copy,
+        T: Default,
+        u32: TryFrom<T>,
+    {
+        let mut result = vec![];
+
+        loop {
+            let m = x % radix;
+            x = x / radix;
+            result.push(
+                std::char::from_digit(m.try_into().ok().unwrap(), radix.try_into().ok().unwrap())
+                    .unwrap(),
+            );
+            if x == T::default() {
+                break;
+            }
+        }
+        result.into_iter().rev().collect()
+    }
+
+    macro_rules! check {
+        ($($t:ty)*) => ($(
+        for base in 2..=36 {
+            let num = (<$t>::MAX as u128) + 1;
+
+           // Calcutate the string length for the smallest overflowing number:
+           let max_len_string = format_radix(num, base as u128);
+           // Ensure that that string length is deemed to potentially overflow:
+           assert_eq!(can_not_overflow::<$t>(base, <$t>::default() > <$t>::MIN, max_len_string.as_bytes()), false);
+        }
+        )*)
+    }
+
+    check! { i8 i16 i32 i64 i128 isize usize u8 u16 u32 u64 }
+}
+
 #[test]
 fn test_leading_plus() {
     test_parse::<u8>("+127", Ok(127));

From e1d27e1b0c1deed73126e6da2ce826b2357f02f0 Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Sun, 10 Apr 2022 18:13:48 +0100
Subject: [PATCH 13/15] Use Add, Sub, Mul traits instead of unsafe

---
 core/src/num/mod.rs   | 60 +++++++++++++++----------------------------
 core/tests/num/mod.rs | 32 ++++++++++++++++++++++-
 2 files changed, 51 insertions(+), 41 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 5bead39a3..4768befce 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -5,6 +5,7 @@
 use crate::ascii;
 use crate::intrinsics;
 use crate::mem;
+use crate::ops::{Add, Mul, Sub};
 use crate::str::FromStr;
 
 // Used because the `?` operator is not allowed in a const context.
@@ -969,14 +970,14 @@ pub enum FpCategory {
 }
 
 #[doc(hidden)]
-trait FromStrRadixHelper: PartialOrd + Copy + Default {
+trait FromStrRadixHelper:
+    PartialOrd + Copy + Default + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self>
+{
     const MIN: Self;
+    fn from_u32(u: u32) -> Self;
     fn checked_mul(&self, other: u32) -> Option<Self>;
     fn checked_sub(&self, other: u32) -> Option<Self>;
     fn checked_add(&self, other: u32) -> Option<Self>;
-    unsafe fn unchecked_mul(self, other: u32) -> Self;
-    unsafe fn unchecked_sub(self, other: u32) -> Self;
-    unsafe fn unchecked_add(self, other: u32) -> Self;
 }
 
 macro_rules! from_str_radix_int_impl {
@@ -996,6 +997,8 @@ macro_rules! impl_helper_for {
     ($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
         const MIN: Self = Self::MIN;
         #[inline]
+        fn from_u32(u: u32) -> Self { u as Self }
+        #[inline]
         fn checked_mul(&self, other: u32) -> Option<Self> {
             Self::checked_mul(*self, other as Self)
         }
@@ -1007,27 +1010,6 @@ macro_rules! impl_helper_for {
         fn checked_add(&self, other: u32) -> Option<Self> {
             Self::checked_add(*self, other as Self)
         }
-        #[inline]
-        unsafe fn unchecked_mul(self, other: u32) -> Self {
-            // SAFETY:  Conditions of `Self::unchecked_mul` must be upheld by the caller.
-            unsafe {
-                Self::unchecked_mul(self, other as Self)
-            }
-        }
-        #[inline]
-        unsafe fn unchecked_sub(self, other: u32) -> Self {
-            // SAFETY:  Conditions of `Self::unchecked_sub` must be upheld by the caller.
-            unsafe {
-                Self::unchecked_sub(self, other as Self)
-            }
-        }
-        #[inline]
-        unsafe fn unchecked_add(self, other: u32) -> Self {
-            // SAFETY: Conditions of `Self::unchecked_add` must be upheld by the caller.
-            unsafe {
-                Self::unchecked_add(self, other as Self)
-            }
-        }
     })*)
 }
 impl_helper_for! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }
@@ -1077,7 +1059,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
     let mut result = T::default();
 
     if can_not_overflow::<T>(radix, is_signed_ty, digits) {
-        // SAFETY: If the len of the str is short compared to the range of the type
+        // If the len of the str is short compared to the range of the type
         // we are parsing into, then we can be certain that an overflow will not occur.
         // This bound is when `radix.pow(digits.len()) - 1 <= T::MAX` but the condition
         // above is a faster (conservative) approximation of this.
@@ -1085,22 +1067,20 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         // Consider radix 16 as it has the highest information density per digit and will thus overflow the earliest:
         // `u8::MAX` is `ff` - any str of len 2 is guaranteed to not overflow.
         // `i8::MAX` is `7f` - only a str of len 1 is guaranteed to not overflow.
-        unsafe {
-            macro_rules! run_unchecked_loop {
-                ($unchecked_additive_op:ident) => {
-                    for &c in digits {
-                        result = result.unchecked_mul(radix);
-                        let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
-                        result = T::$unchecked_additive_op(result, x);
-                    }
-                };
-            }
-            if is_positive {
-                run_unchecked_loop!(unchecked_add)
-            } else {
-                run_unchecked_loop!(unchecked_sub)
+        macro_rules! run_unchecked_loop {
+            ($unchecked_additive_op:expr) => {
+                for &c in digits {
+                    result = result * T::from_u32(radix);
+                    let x = (c as char).to_digit(radix).ok_or(PIE { kind: InvalidDigit })?;
+                    result = $unchecked_additive_op(result, T::from_u32(x));
+                }
             };
         }
+        if is_positive {
+            run_unchecked_loop!(<T as core::ops::Add>::add)
+        } else {
+            run_unchecked_loop!(<T as core::ops::Sub>::sub)
+        };
     } else {
         macro_rules! run_checked_loop {
             ($checked_additive_op:ident, $overflow_err:expr) => {
diff --git a/core/tests/num/mod.rs b/core/tests/num/mod.rs
index 0abc88f21..10b8d9754 100644
--- a/core/tests/num/mod.rs
+++ b/core/tests/num/mod.rs
@@ -122,6 +122,28 @@ fn test_int_from_str_overflow() {
 
 #[test]
 fn test_can_not_overflow() {
+    fn can_overflow<T>(radix: u32, input: &str) -> bool
+    where
+        T: Default
+            + core::ops::Sub<Output = T>
+            + std::convert::From<bool>
+            + std::cmp::PartialOrd
+            + Copy,
+    {
+        let one = true.into();
+        let zero = <T>::default();
+        !can_not_overflow::<T>(radix, zero - one < zero, input.as_bytes())
+    }
+
+    // Positive tests:
+    assert!(!can_overflow::<i8>(16, "F"));
+    assert!(!can_overflow::<u8>(16, "FF"));
+
+    assert!(!can_overflow::<i8>(10, "9"));
+    assert!(!can_overflow::<u8>(10, "99"));
+
+    // Negative tests:
+
     // Not currently in std lib (issue: #27728)
     fn format_radix<T>(mut x: T, radix: T) -> String
     where
@@ -157,12 +179,20 @@ fn test_can_not_overflow() {
            // Calcutate the string length for the smallest overflowing number:
            let max_len_string = format_radix(num, base as u128);
            // Ensure that that string length is deemed to potentially overflow:
-           assert_eq!(can_not_overflow::<$t>(base, <$t>::default() > <$t>::MIN, max_len_string.as_bytes()), false);
+           assert!(can_overflow::<$t>(base, &max_len_string));
         }
         )*)
     }
 
     check! { i8 i16 i32 i64 i128 isize usize u8 u16 u32 u64 }
+
+    // Check u128 separately:
+    for base in 2..=36 {
+        let num = u128::MAX as u128;
+        let max_len_string = format_radix(num, base as u128);
+        // base 16 fits perfectly for u128 and won't overflow:
+        assert_eq!(can_overflow::<u128>(base, &max_len_string), base != 16);
+    }
 }
 
 #[test]

From 568ec2af0b41afbd63f434df03e2fb5e75b808e9 Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Sun, 10 Apr 2022 18:20:13 +0100
Subject: [PATCH 14/15] No need to use Default

---
 core/src/num/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/num/mod.rs b/core/src/num/mod.rs
index 4768befce..fff9bddc4 100644
--- a/core/src/num/mod.rs
+++ b/core/src/num/mod.rs
@@ -971,7 +971,7 @@ pub enum FpCategory {
 
 #[doc(hidden)]
 trait FromStrRadixHelper:
-    PartialOrd + Copy + Default + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self>
+    PartialOrd + Copy + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self>
 {
     const MIN: Self;
     fn from_u32(u: u32) -> Self;
@@ -1039,7 +1039,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         return Err(PIE { kind: Empty });
     }
 
-    let is_signed_ty = T::default() > T::MIN;
+    let is_signed_ty = T::from_u32(0) > T::MIN;
 
     // all valid digits are ascii, so we will just iterate over the utf8 bytes
     // and cast them to chars. .to_digit() will safely return None for anything
@@ -1056,7 +1056,7 @@ fn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, Par
         _ => (true, src),
     };
 
-    let mut result = T::default();
+    let mut result = T::from_u32(0);
 
     if can_not_overflow::<T>(radix, is_signed_ty, digits) {
         // If the len of the str is short compared to the range of the type

From de6cb9e8875d8a8577a8ced764fb3e2fa5d9ba3f Mon Sep 17 00:00:00 2001
From: Giles Cope <gilescope@gmail.com>
Date: Mon, 11 Apr 2022 07:37:53 +0100
Subject: [PATCH 15/15] better def of is signed in tests.

---
 core/tests/num/mod.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/core/tests/num/mod.rs b/core/tests/num/mod.rs
index 10b8d9754..49580cdcc 100644
--- a/core/tests/num/mod.rs
+++ b/core/tests/num/mod.rs
@@ -124,15 +124,9 @@ fn test_int_from_str_overflow() {
 fn test_can_not_overflow() {
     fn can_overflow<T>(radix: u32, input: &str) -> bool
     where
-        T: Default
-            + core::ops::Sub<Output = T>
-            + std::convert::From<bool>
-            + std::cmp::PartialOrd
-            + Copy,
+        T: std::convert::TryFrom<i8>,
     {
-        let one = true.into();
-        let zero = <T>::default();
-        !can_not_overflow::<T>(radix, zero - one < zero, input.as_bytes())
+        !can_not_overflow::<T>(radix, T::try_from(-1_i8).is_ok(), input.as_bytes())
     }
 
     // Positive tests: