Merge pull request #637 from folkertdev/min-max-assoc-constants

use associated constants for `NAN`, `MIN` and `MAX`

Author: tzemanovic

proptest/src/arbitrary/_alloc/char.rs

@@ -22,7 +22,7 @@ multiplex_alloc! {
     core::char::decode_utf16, std::char::decode_utf16
 }
 
-const VEC_MAX: usize = ::core::u16::MAX as usize;
+const VEC_MAX: usize = u16::MAX as usize;
 
 use crate::arbitrary::*;
 use crate::strategy::statics::static_map;

proptest/src/arbitrary/_std/env.rs

@@ -77,8 +77,8 @@ mod var_error {
     #[cfg(target_os = "windows")]
     fn osstring_invalid_string() -> impl Strategy<Value = OsString> {
         use std::os::windows::ffi::OsStringExt;
-        let size = 1..::std::u16::MAX as usize;
-        let vec_gen = crate::collection::vec(..::std::u16::MAX, size.clone());
+        let size = 1..u16::MAX as usize;
+        let vec_gen = crate::collection::vec(..u16::MAX, size.clone());
         (size, vec_gen).prop_map(|(p, mut sbuf)| {
             // Not quite a uniform distribution due to clamping,
             // but probably good enough

proptest/src/arbitrary/_std/ffi.rs

@@ -22,7 +22,7 @@ use super::string::not_utf8_bytes;
 
 arbitrary!(CString,
     SFnPtrMap<VecStrategy<RangeInclusive<u8>>, Self>, SizeRange;
-    args => static_map(vec(1..=::std::u8::MAX, args + 1), |mut vec| {
+    args => static_map(vec(1..=u8::MAX, args + 1), |mut vec| {
         vec.pop().unwrap();
         // Could use: Self::from_vec_unchecked(vec) safely.
         Self::new(vec).unwrap()

proptest/src/arbitrary/_std/string.rs

@@ -70,7 +70,7 @@ arbitrary!(FromUtf8Error, SFnPtrMap<BoxedStrategy<Vec<u8>>, Self>;
 pub(crate) fn not_utf8_bytes(
     allow_null: bool,
 ) -> impl Strategy<Value = Vec<u8>> {
-    let prefix = collection::vec(any::<char>(), ..::std::u16::MAX as usize);
+    let prefix = collection::vec(any::<char>(), ..u16::MAX as usize);
     let suffix = gen_el_bytes(allow_null);
     (prefix, suffix).prop_map(move |(prefix_bytes, el_bytes)| {
         let iter = prefix_bytes.iter();

proptest/src/char.rs

@@ -207,7 +207,7 @@ impl<'a> CharStrategy<'a> {
     }
 }
 
-const WHOLE_RANGE: &[CharRange] = &['\x00'..=::core::char::MAX];
+const WHOLE_RANGE: &[CharRange] = &['\x00'..=char::MAX];
 
 /// Creates a `CharStrategy` which picks from literally any character, with the
 /// default biases.
@@ -327,8 +327,8 @@ mod test {
     proptest! {
         #[test]
         fn stays_in_range(input_ranges in collection::vec(
-            (0..::std::char::MAX as u32,
-             0..::std::char::MAX as u32),
+            (0..char::MAX as u32,
+             0..char::MAX as u32),
             1..5))
         {
             let input = ranges(Cow::Owned(input_ranges.iter().map(

proptest/src/collection.rs

@@ -32,10 +32,10 @@ use crate::tuple::TupleValueTree;
 //==============================================================================
 
 /// The minimum and maximum range/bounds on the size of a collection.
-/// The interval must form a subset of `[0, std::usize::MAX)`.
+/// The interval must form a subset of `[0, usize::MAX)`.
 ///
-/// A value like `0..=std::usize::MAX` will still be accepted but will silently
-/// truncate the maximum to `std::usize::MAX - 1`.
+/// A value like `0..=usize::MAX` will still be accepted but will silently
+/// truncate the maximum to `usize::MAX - 1`.
 ///
 /// The `Default` is `0..PROPTEST_MAX_DEFAULT_SIZE_RANGE`. The max can be set with
 /// the `PROPTEST_MAX_DEFAULT_SIZE_RANGE` env var, which defaults to `100`.

proptest/src/num.rs

@@ -185,10 +185,10 @@ macro_rules! numeric_api {
                     $crate::num::$incl::<$sample_typ>(
                         runner,
                         self.start.into(),
-                        ::core::$typ::MAX.into(),
+                        <$typ>::MAX.into(),
                     )
                     .into(),
-                    ::core::$typ::MAX,
+                    <$typ>::MAX,
                 ))
             }
         }
@@ -199,10 +199,10 @@ macro_rules! numeric_api {
 
             fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
                 Ok(BinarySearch::new_clamped(
-                    ::core::$typ::MIN,
+                    <$typ>::MIN,
                     $crate::num::$uniform::<$sample_typ>(
                         runner,
-                        ::core::$typ::MIN.into(),
+                        <$typ>::MIN.into(),
                         self.end.into(),
                     )
                     .into(),
@@ -217,10 +217,10 @@ macro_rules! numeric_api {
 
             fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
                 Ok(BinarySearch::new_clamped(
-                    ::core::$typ::MIN,
+                    <$typ>::MIN,
                     $crate::num::$incl::<$sample_typ>(
                         runner,
-                        ::core::$typ::MIN.into(),
+                        <$typ>::MIN.into(),
                         self.end.into(),
                     )
                     .into(),
@@ -718,7 +718,7 @@ macro_rules! float_any {
                 // signalling bit. Assume the `NAN` constant is a quiet NaN as
                 // interpreted by the hardware and generate values based on
                 // that.
-                let quiet_or = ::core::$typ::NAN.to_bits() &
+                let quiet_or = $typ::NAN.to_bits() &
                     ($typ::EXP_MASK | ($typ::EXP_MASK >> 1));
                 let signaling_or = (quiet_or ^ ($typ::EXP_MASK >> 1)) |
                     $typ::EXP_MASK;
@@ -1277,13 +1277,13 @@ mod test {
     #[test]
     fn float_simplifies_to_smallest_normal() {
         let mut runner = TestRunner::default();
-        let mut value = (::std::f64::MIN_POSITIVE..2.0)
+        let mut value = (f64::MIN_POSITIVE..2.0)
             .new_tree(&mut runner)
             .unwrap();
 
         while value.simplify() {}
 
-        assert_eq!(::std::f64::MIN_POSITIVE, value.current());
+        assert_eq!(f64::MIN_POSITIVE, value.current());
     }
 
     macro_rules! float_generation_test_body {
@@ -1343,8 +1343,7 @@ mod test {
                             }
 
                             let is_quiet = raw & ($typ::EXP_MASK >> 1)
-                                == ::std::$typ::NAN.to_bits()
-                                    & ($typ::EXP_MASK >> 1);
+                                == $typ::NAN.to_bits() & ($typ::EXP_MASK >> 1);
                             if is_quiet {
                                 // x86/AMD64 turn signalling NaNs into quiet
                                 // NaNs quite aggressively depending on what

proptest/src/string.rs

@@ -244,11 +244,11 @@ fn unicode_class_strategy(
         // Multiple instances of the latter range to partially make up
         // for the bias of having such a tiny range in the control
         // characters.
-        '\x0B'..=::core::char::MAX,
-        '\x0B'..=::core::char::MAX,
-        '\x0B'..=::core::char::MAX,
-        '\x0B'..=::core::char::MAX,
-        '\x0B'..=::core::char::MAX,
+        '\x0B'..=char::MAX,
+        '\x0B'..=char::MAX,
+        '\x0B'..=char::MAX,
+        '\x0B'..=char::MAX,
+        '\x0B'..=char::MAX,
     ];
 
     let dotnnl = |x: &hir::ClassUnicodeRange, y: &hir::ClassUnicodeRange| {

proptest/src/test_runner/config.rs

@@ -356,15 +356,15 @@ pub struct Config {
     /// Give up on shrinking if more than this number of iterations of the test
     /// code are run.
     ///
-    /// Setting this to `std::u32::MAX` causes the actual limit to be four
+    /// Setting this to `u32::MAX` causes the actual limit to be four
     /// times the number of test cases.
     ///
     /// Setting this value to `0` disables shrinking altogether.
     ///
     /// Note that the type of this field will change in a future version of
     /// proptest to better accommodate its special values.
     ///
-    /// The default is `std::u32::MAX`, which can be overridden by setting the
+    /// The default is `u32::MAX`, which can be overridden by setting the
     /// `PROPTEST_MAX_SHRINK_ITERS` environment variable. (The variable is only
     /// considered when the `std` feature is enabled, which it is by default.)
     pub max_shrink_iters: u32,