Change return type for T::{log,log2,log10} to u32. The value is at

Falk Hüffner · Falk Hüffner · commit d760c3318391 · 2021-09-05T17:09:21.000+02:00
most 128, and this is consistent with using u32 for small values
elsewhere (e.g. BITS, count_ones, leading_zeros).
diff --git a/library/core/src/num/int_log10.rs b/library/core/src/num/int_log10.rs
@@ -116,8 +116,8 @@ mod unchecked {
 
 macro_rules! impl_checked {
     ($T:ident) => {
-        pub const fn $T(val: $T) -> Option<$T> {
-            if val > 0 { Some(unchecked::$T(val) as $T) } else { None }
+        pub const fn $T(val: $T) -> Option<u32> {
+            if val > 0 { Some(unchecked::$T(val)) } else { None }
         }
     };
 }
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
@@ -2026,7 +2026,7 @@ macro_rules! int_impl {
         #[track_caller]
         #[rustc_inherit_overflow_checks]
         #[allow(arithmetic_overflow)]
-        pub const fn log(self, base: Self) -> Self {
+        pub const fn log(self, base: Self) -> u32 {
             match self.checked_log(base) {
                 Some(n) => n,
                 None => {
@@ -2060,7 +2060,7 @@ macro_rules! int_impl {
         #[track_caller]
         #[rustc_inherit_overflow_checks]
         #[allow(arithmetic_overflow)]
-        pub const fn log2(self) -> Self {
+        pub const fn log2(self) -> u32 {
             match self.checked_log2() {
                 Some(n) => n,
                 None => {
@@ -2094,7 +2094,7 @@ macro_rules! int_impl {
         #[track_caller]
         #[rustc_inherit_overflow_checks]
         #[allow(arithmetic_overflow)]
-        pub const fn log10(self) -> Self {
+        pub const fn log10(self) -> u32 {
             match self.checked_log10() {
                 Some(n) => n,
                 None => {
@@ -2125,7 +2125,7 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                         without modifying the original"]
         #[inline]
-        pub const fn checked_log(self, base: Self) -> Option<Self> {
+        pub const fn checked_log(self, base: Self) -> Option<u32> {
             if self <= 0 || base <= 1 {
                 None
             } else {
@@ -2161,12 +2161,12 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                         without modifying the original"]
         #[inline]
-        pub const fn checked_log2(self) -> Option<Self> {
+        pub const fn checked_log2(self) -> Option<u32> {
             if self <= 0 {
                 None
             } else {
                 // SAFETY: We just checked that this number is positive
-                let log = (Self::BITS - 1) as Self - unsafe { intrinsics::ctlz_nonzero(self) };
+                let log = (Self::BITS - 1) - unsafe { intrinsics::ctlz_nonzero(self) as u32 };
                 Some(log)
             }
         }
@@ -2185,11 +2185,8 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                         without modifying the original"]
         #[inline]
-        pub const fn checked_log10(self) -> Option<Self> {
-            match int_log10::$ActualT(self as $ActualT) {
-                Some(s) => Some(s as Self),
-                None => None,
-            }
+        pub const fn checked_log10(self) -> Option<u32> {
+            int_log10::$ActualT(self as $ActualT)
         }
 
         /// Computes the absolute value of `self`.
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
@@ -660,7 +660,7 @@ macro_rules! uint_impl {
         #[track_caller]
         #[rustc_inherit_overflow_checks]
         #[allow(arithmetic_overflow)]
-        pub const fn log(self, base: Self) -> Self {
+        pub const fn log(self, base: Self) -> u32 {
             match self.checked_log(base) {
                 Some(n) => n,
                 None => {
@@ -694,7 +694,7 @@ macro_rules! uint_impl {
         #[track_caller]
         #[rustc_inherit_overflow_checks]
         #[allow(arithmetic_overflow)]
-        pub const fn log2(self) -> Self {
+        pub const fn log2(self) -> u32 {
             match self.checked_log2() {
                 Some(n) => n,
                 None => {
@@ -728,7 +728,7 @@ macro_rules! uint_impl {
         #[track_caller]
         #[rustc_inherit_overflow_checks]
         #[allow(arithmetic_overflow)]
-        pub const fn log10(self) -> Self {
+        pub const fn log10(self) -> u32 {
             match self.checked_log10() {
                 Some(n) => n,
                 None => {
@@ -759,7 +759,7 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                         without modifying the original"]
         #[inline]
-        pub const fn checked_log(self, base: Self) -> Option<Self> {
+        pub const fn checked_log(self, base: Self) -> Option<u32> {
             if self <= 0 || base <= 1 {
                 None
             } else {
@@ -795,12 +795,12 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                         without modifying the original"]
         #[inline]
-        pub const fn checked_log2(self) -> Option<Self> {
+        pub const fn checked_log2(self) -> Option<u32> {
             if self <= 0 {
                 None
             } else {
                 // SAFETY: We just checked that this number is positive
-                let log = (Self::BITS - 1) as Self - unsafe { intrinsics::ctlz_nonzero(self) };
+                let log = (Self::BITS - 1) - unsafe { intrinsics::ctlz_nonzero(self) as u32 };
                 Some(log)
             }
         }
@@ -819,11 +819,8 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                         without modifying the original"]
         #[inline]
-        pub const fn checked_log10(self) -> Option<Self> {
-            match int_log10::$ActualT(self as $ActualT) {
-                Some(s) => Some(s as Self),
-                None => None,
-            }
+        pub const fn checked_log10(self) -> Option<u32> {
+            int_log10::$ActualT(self as $ActualT)
         }
 
         /// Checked negation. Computes `-self`, returning `None` unless `self ==
diff --git a/library/core/tests/num/int_log.rs b/library/core/tests/num/int_log.rs
@@ -26,10 +26,10 @@ fn checked_log() {
         assert_eq!(i.checked_log(4), None);
     }
     for i in 1..=i16::MAX {
-        assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as i16));
+        assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u32));
     }
     for i in 1..=u16::MAX {
-        assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u16));
+        assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u32));
     }
 }
 
@@ -46,27 +46,27 @@ fn checked_log2() {
     assert_eq!(0i16.checked_log2(), None);
 
     for i in 1..=u8::MAX {
-        assert_eq!(i.checked_log2(), Some((i as f32).log2() as u8));
+        assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
     }
     for i in 1..=u16::MAX {
         // Guard against Android's imprecise f32::log2 implementation.
         if i != 8192 && i != 32768 {
-            assert_eq!(i.checked_log2(), Some((i as f32).log2() as u16));
+            assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
         }
     }
     for i in i8::MIN..=0 {
         assert_eq!(i.checked_log2(), None);
     }
     for i in 1..=i8::MAX {
-        assert_eq!(i.checked_log2(), Some((i as f32).log2() as i8));
+        assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
     }
     for i in i16::MIN..=0 {
         assert_eq!(i.checked_log2(), None);
     }
     for i in 1..=i16::MAX {
         // Guard against Android's imprecise f32::log2 implementation.
         if i != 8192 {
-            assert_eq!(i.checked_log2(), Some((i as f32).log2() as i16));
+            assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));
         }
     }
 }
@@ -75,9 +75,9 @@ fn checked_log2() {
 #[test]
 #[cfg(not(target_os = "android"))]
 fn checked_log2_not_android() {
-    assert_eq!(8192u16.checked_log2(), Some((8192f32).log2() as u16));
-    assert_eq!(32768u16.checked_log2(), Some((32768f32).log2() as u16));
-    assert_eq!(8192i16.checked_log2(), Some((8192f32).log2() as i16));
+    assert_eq!(8192u16.checked_log2(), Some((8192f32).log2() as u32));
+    assert_eq!(32768u16.checked_log2(), Some((32768f32).log2() as u32));
+    assert_eq!(8192i16.checked_log2(), Some((8192f32).log2() as u32));
 }
 
 #[test]
@@ -91,10 +91,10 @@ fn checked_log10() {
         assert_eq!(i.checked_log10(), None);
     }
     for i in 1..=i16::MAX {
-        assert_eq!(i.checked_log10(), Some((i as f32).log10() as i16));
+        assert_eq!(i.checked_log10(), Some((i as f32).log10() as u32));
     }
     for i in 1..=u16::MAX {
-        assert_eq!(i.checked_log10(), Some((i as f32).log10() as u16));
+        assert_eq!(i.checked_log10(), Some((i as f32).log10() as u32));
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -116,8 +116,8 @@ mod unchecked {`
`116`	`116`
`117`	`117`	`macro_rules! impl_checked {`
`118`	`118`	`($T:ident) => {`
`119`		`- pub const fn $T(val: $T) -> Option<$T> {`
`120`		`- if val > 0 { Some(unchecked::$T(val) as $T) } else { None }`
	`119`	`+ pub const fn $T(val: $T) -> Option<u32> {`
	`120`	`+ if val > 0 { Some(unchecked::$T(val)) } else { None }`
`121`	`121`	`}`
`122`	`122`	`};`
`123`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,10 +26,10 @@ fn checked_log() {`
`26`	`26`	`assert_eq!(i.checked_log(4), None);`
`27`	`27`	`}`
`28`	`28`	`for i in 1..=i16::MAX {`
`29`		`- assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as i16));`
	`29`	`+ assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u32));`
`30`	`30`	`}`
`31`	`31`	`for i in 1..=u16::MAX {`
`32`		`- assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u16));`
	`32`	`+ assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u32));`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`@@ -46,27 +46,27 @@ fn checked_log2() {`
`46`	`46`	`assert_eq!(0i16.checked_log2(), None);`
`47`	`47`
`48`	`48`	`for i in 1..=u8::MAX {`
`49`		`- assert_eq!(i.checked_log2(), Some((i as f32).log2() as u8));`
	`49`	`+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));`
`50`	`50`	`}`
`51`	`51`	`for i in 1..=u16::MAX {`
`52`	`52`	`// Guard against Android's imprecise f32::log2 implementation.`
`53`	`53`	`if i != 8192 && i != 32768 {`
`54`		`- assert_eq!(i.checked_log2(), Some((i as f32).log2() as u16));`
	`54`	`+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`	`for i in i8::MIN..=0 {`
`58`	`58`	`assert_eq!(i.checked_log2(), None);`
`59`	`59`	`}`
`60`	`60`	`for i in 1..=i8::MAX {`
`61`		`- assert_eq!(i.checked_log2(), Some((i as f32).log2() as i8));`
	`61`	`+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));`
`62`	`62`	`}`
`63`	`63`	`for i in i16::MIN..=0 {`
`64`	`64`	`assert_eq!(i.checked_log2(), None);`
`65`	`65`	`}`
`66`	`66`	`for i in 1..=i16::MAX {`
`67`	`67`	`// Guard against Android's imprecise f32::log2 implementation.`
`68`	`68`	`if i != 8192 {`
`69`		`- assert_eq!(i.checked_log2(), Some((i as f32).log2() as i16));`
	`69`	`+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as u32));`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`	`}`
`@@ -75,9 +75,9 @@ fn checked_log2() {`
`75`	`75`	`#[test]`
`76`	`76`	`#[cfg(not(target_os = "android"))]`
`77`	`77`	`fn checked_log2_not_android() {`
`78`		`- assert_eq!(8192u16.checked_log2(), Some((8192f32).log2() as u16));`
`79`		`- assert_eq!(32768u16.checked_log2(), Some((32768f32).log2() as u16));`
`80`		`- assert_eq!(8192i16.checked_log2(), Some((8192f32).log2() as i16));`
	`78`	`+ assert_eq!(8192u16.checked_log2(), Some((8192f32).log2() as u32));`
	`79`	`+ assert_eq!(32768u16.checked_log2(), Some((32768f32).log2() as u32));`
	`80`	`+ assert_eq!(8192i16.checked_log2(), Some((8192f32).log2() as u32));`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`#[test]`
`@@ -91,10 +91,10 @@ fn checked_log10() {`
`91`	`91`	`assert_eq!(i.checked_log10(), None);`
`92`	`92`	`}`
`93`	`93`	`for i in 1..=i16::MAX {`
`94`		`- assert_eq!(i.checked_log10(), Some((i as f32).log10() as i16));`
	`94`	`+ assert_eq!(i.checked_log10(), Some((i as f32).log10() as u32));`
`95`	`95`	`}`
`96`	`96`	`for i in 1..=u16::MAX {`
`97`		`- assert_eq!(i.checked_log10(), Some((i as f32).log10() as u16));`
	`97`	`+ assert_eq!(i.checked_log10(), Some((i as f32).log10() as u32));`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`