refactor: Deduplicate pow implementations

`wrapping_pow`, `strict_pow` and `checked_pow` can all be implemented in
terms of `overflowing_pow`.

Author: Kmeakin

library/core/src/num/overflow_panic.rs

@@ -32,6 +32,12 @@ pub(super) const fn rem() -> ! {
     panic!("attempt to calculate the remainder with overflow")
 }
 
+#[cold]
+#[track_caller]
+pub(super) const fn pow() -> ! {
+    panic!("attempt to calculate the power with overflow")
+}
+
 #[cold]
 #[track_caller]
 pub(super) const fn neg() -> ! {

library/core/src/num/uint_macros.rs

@@ -2071,24 +2071,9 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const fn checked_pow(self, mut exp: u32) -> Option<Self> {
-            if exp == 0 {
-                return Some(1);
-            }
-            let mut base = self;
-            let mut acc: Self = 1;
-
-            loop {
-                if (exp & 1) == 1 {
-                    acc = try_opt!(acc.checked_mul(base));
-                    // since exp!=0, finally the exp must be 1.
-                    if exp == 1 {
-                        return Some(acc);
-                    }
-                }
-                exp /= 2;
-                base = try_opt!(base.checked_mul(base));
-            }
+        pub const fn checked_pow(self, exp: u32) -> Option<Self> {
+            let (a, b) = self.overflowing_pow(exp);
+            if b { None } else { Some(a) }
         }
 
         /// Strict exponentiation. Computes `self.pow(exp)`, panicking if
@@ -2117,24 +2102,9 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         #[track_caller]
-        pub const fn strict_pow(self, mut exp: u32) -> Self {
-            if exp == 0 {
-                return 1;
-            }
-            let mut base = self;
-            let mut acc: Self = 1;
-
-            loop {
-                if (exp & 1) == 1 {
-                    acc = acc.strict_mul(base);
-                    // since exp!=0, finally the exp must be 1.
-                    if exp == 1 {
-                        return acc;
-                    }
-                }
-                exp /= 2;
-                base = base.strict_mul(base);
-            }
+        pub const fn strict_pow(self, exp: u32) -> Self {
+            let (a, b) = self.overflowing_pow(exp);
+            if b { overflow_panic::pow() } else { a }
         }
 
         /// Saturating integer addition. Computes `self + rhs`, saturating at
@@ -2593,43 +2563,9 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const fn wrapping_pow(self, mut exp: u32) -> Self {
-            if exp == 0 {
-                return 1;
-            }
-            let mut base = self;
-            let mut acc: Self = 1;
-
-            if intrinsics::is_val_statically_known(exp) {
-                while exp > 1 {
-                    if (exp & 1) == 1 {
-                        acc = acc.wrapping_mul(base);
-                    }
-                    exp /= 2;
-                    base = base.wrapping_mul(base);
-                }
-
-                // since exp!=0, finally the exp must be 1.
-                // Deal with the final bit of the exponent separately, since
-                // squaring the base afterwards is not necessary.
-                acc.wrapping_mul(base)
-            } else {
-                // This is faster than the above when the exponent is not known
-                // at compile time. We can't use the same code for the constant
-                // exponent case because LLVM is currently unable to unroll
-                // this loop.
-                loop {
-                    if (exp & 1) == 1 {
-                        acc = acc.wrapping_mul(base);
-                        // since exp!=0, finally the exp must be 1.
-                        if exp == 1 {
-                            return acc;
-                        }
-                    }
-                    exp /= 2;
-                    base = base.wrapping_mul(base);
-                }
-            }
+        pub const fn wrapping_pow(self, exp: u32) -> Self {
+            let (a, _) = self.overflowing_pow(exp);
+            a
         }
 
         /// Calculates `self` + `rhs`.
@@ -3269,8 +3205,8 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         pub const fn overflowing_pow(self, mut exp: u32) -> (Self, bool) {
-            if exp == 0{
-                return (1,false);
+            if exp == 0 {
+                return (1, false);
             }
             let mut base = self;
             let mut acc: Self = 1;