Merge remote-tracking branch 'upstream/master' into round_ties_even

Author: bushrat011899

.github/workflows/ci.yaml

@@ -11,6 +11,7 @@ jobs:
         rust: [
           1.60.0, # MSRV
           1.62.0, # has_total_cmp
+          1.74.0, # has_num_saturating
           stable,
           beta,
           nightly,

Cargo.toml

@@ -31,4 +31,4 @@ std = []
 i128 = []
 
 [build-dependencies]
-autocfg = "1"
+autocfg = "1.2"

build.rs

@@ -1,7 +1,9 @@
 fn main() {
-    let ac = autocfg::new();
+    let mut ac = autocfg::new();
+    ac.set_no_std(true);
 
     ac.emit_expression_cfg("1f64.total_cmp(&2f64)", "has_total_cmp"); // 1.62
+    ac.emit_path_cfg("core::num::Saturating", "has_num_saturating"); // 1.74
     ac.emit_expression_cfg("1.5f64.round_ties_even()", "has_round_ties_even"); // 1.77
 
     autocfg::rerun_path("build.rs");

ci/rustup.sh

@@ -5,6 +5,6 @@
 set -ex
 
 ci=$(dirname $0)
-for version in 1.60.0 1.62.0 stable beta nightly; do
+for version in 1.60.0 1.62.0 1.74.0 stable beta nightly; do
     rustup run "$version" "$ci/test_full.sh"
 done

ci/test_full.sh

@@ -31,6 +31,7 @@ FEATURES=(libm)
 echo "Testing supported features: ${FEATURES[*]}"
 
 cargo generate-lockfile
+check_version 1.63.0 || cargo update -p libm --precise 0.2.9
 
 set -x
 

src/bounds.rs

@@ -1,4 +1,8 @@
 use core::num::Wrapping;
+use core::num::{
+    NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
+    NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
+};
 use core::{f32, f64};
 use core::{i128, i16, i32, i64, i8, isize};
 use core::{u128, u16, u32, u64, u8, usize};
@@ -68,6 +72,49 @@ bounded_impl!(i32, i32::MIN, i32::MAX);
 bounded_impl!(i64, i64::MIN, i64::MAX);
 bounded_impl!(i128, i128::MIN, i128::MAX);
 
+macro_rules! bounded_impl_nonzero_const {
+    ($t:ty, $v:expr, $i:ident) => {
+        const $i: $t = match <$t>::new($v) {
+            Some(nz) => nz,
+            None => panic!("bad nonzero bound!"),
+        };
+    };
+}
+
+macro_rules! bounded_impl_nonzero {
+    ($t:ty, $min:expr, $max:expr) => {
+        impl Bounded for $t {
+            #[inline]
+            fn min_value() -> $t {
+                // when MSRV is 1.70 we can use $t::MIN
+                bounded_impl_nonzero_const!($t, $min, MIN);
+                MIN
+            }
+
+            #[inline]
+            fn max_value() -> $t {
+                // when MSRV is 1.70 we can use $t::MAX
+                bounded_impl_nonzero_const!($t, $max, MAX);
+                MAX
+            }
+        }
+    };
+}
+
+bounded_impl_nonzero!(NonZeroUsize, 1, usize::MAX);
+bounded_impl_nonzero!(NonZeroU8, 1, u8::MAX);
+bounded_impl_nonzero!(NonZeroU16, 1, u16::MAX);
+bounded_impl_nonzero!(NonZeroU32, 1, u32::MAX);
+bounded_impl_nonzero!(NonZeroU64, 1, u64::MAX);
+bounded_impl_nonzero!(NonZeroU128, 1, u128::MAX);
+
+bounded_impl_nonzero!(NonZeroIsize, isize::MIN, isize::MAX);
+bounded_impl_nonzero!(NonZeroI8, i8::MIN, i8::MAX);
+bounded_impl_nonzero!(NonZeroI16, i16::MIN, i16::MAX);
+bounded_impl_nonzero!(NonZeroI32, i32::MIN, i32::MAX);
+bounded_impl_nonzero!(NonZeroI64, i64::MIN, i64::MAX);
+bounded_impl_nonzero!(NonZeroI128, i128::MIN, i128::MAX);
+
 impl<T: Bounded> Bounded for Wrapping<T> {
     fn min_value() -> Self {
         Wrapping(T::min_value())
@@ -146,3 +193,37 @@ fn wrapping_is_bounded() {
     require_bounded(&Wrapping(42_u32));
     require_bounded(&Wrapping(-42));
 }
+
+#[test]
+fn bounded_unsigned_nonzero() {
+    macro_rules! test_bounded_impl_unsigned_nonzero {
+        ($t:ty, $base_ty:ty) => {
+            assert_eq!(<$t as Bounded>::min_value().get(), 1);
+            assert_eq!(<$t as Bounded>::max_value().get(), <$base_ty>::MAX);
+        };
+    }
+
+    test_bounded_impl_unsigned_nonzero!(NonZeroUsize, usize);
+    test_bounded_impl_unsigned_nonzero!(NonZeroU8, u8);
+    test_bounded_impl_unsigned_nonzero!(NonZeroU16, u16);
+    test_bounded_impl_unsigned_nonzero!(NonZeroU32, u32);
+    test_bounded_impl_unsigned_nonzero!(NonZeroU64, u64);
+    test_bounded_impl_unsigned_nonzero!(NonZeroU128, u128);
+}
+
+#[test]
+fn bounded_signed_nonzero() {
+    macro_rules! test_bounded_impl_signed_nonzero {
+        ($t:ty, $base_ty:ty) => {
+            assert_eq!(<$t as Bounded>::min_value().get(), <$base_ty>::MIN);
+            assert_eq!(<$t as Bounded>::max_value().get(), <$base_ty>::MAX);
+        };
+    }
+
+    test_bounded_impl_signed_nonzero!(NonZeroIsize, isize);
+    test_bounded_impl_signed_nonzero!(NonZeroI8, i8);
+    test_bounded_impl_signed_nonzero!(NonZeroI16, i16);
+    test_bounded_impl_signed_nonzero!(NonZeroI32, i32);
+    test_bounded_impl_signed_nonzero!(NonZeroI64, i64);
+    test_bounded_impl_signed_nonzero!(NonZeroI128, i128);
+}