finally stop using min/max_value and the integer modules

Author: RalfJung

rust-version

@@ -1 +1 @@
-4d71c164a89b705df6affd31a5262c832d1bc48d
+7a3700c37132385e8e965c18e73d0a09f9146335

src/shims/foreign_items.rs

@@ -443,10 +443,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
                 // Saturating cast to i16. Even those are outside the valid exponent range to
                 // `scalbn` below will do its over/underflow handling.
-                let exp = if exp > i16::max_value() as i32 {
-                    i16::max_value()
-                } else if exp < i16::min_value() as i32 {
-                    i16::min_value()
+                let exp = if exp > i16::MAX as i32 {
+                    i16::MAX
+                } else if exp < i16::MIN as i32 {
+                    i16::MIN
                 } else {
                     exp.try_into().unwrap()
                 };

src/shims/fs.rs

@@ -427,15 +427,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         // We cap the number of read bytes to the largest value that we are able to fit in both the
         // host's and target's `isize`. This saves us from having to handle overflows later.
-        let count = count.min(this.isize_max() as u64).min(isize::max_value() as u64);
+        let count = count.min(this.isize_max() as u64).min(isize::MAX as u64);
 
         if let Some(FileHandle { file, writable: _ }) = this.machine.file_handler.handles.get_mut(&fd) {
             // This can never fail because `count` was capped to be smaller than
-            // `isize::max_value()`.
+            // `isize::MAX`.
             let count = isize::try_from(count).unwrap();
             // We want to read at most `count` bytes. We are sure that `count` is not negative
             // because it was a target's `usize`. Also we are sure that its smaller than
-            // `usize::max_value()` because it is a host's `isize`.
+            // `usize::MAX` because it is a host's `isize`.
             let mut bytes = vec![0; count as usize];
             let result = file
                 .read(&mut bytes)
@@ -481,7 +481,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
         // We cap the number of written bytes to the largest value that we are able to fit in both the
         // host's and target's `isize`. This saves us from having to handle overflows later.
-        let count = count.min(this.isize_max() as u64).min(isize::max_value() as u64);
+        let count = count.min(this.isize_max() as u64).min(isize::MAX as u64);
 
         if let Some(FileHandle { file, writable: _ }) = this.machine.file_handler.handles.get_mut(&fd) {
             let bytes = this.memory.read_bytes(buf, Size::from_bytes(count))?;

src/shims/mod.rs

@@ -27,7 +27,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             let (dest, ret) = ret.unwrap();
             let n = this
                 .align_offset(args[0], args[1])?
-                .unwrap_or_else(|| this.truncate(u128::max_value(), dest.layout));
+                .unwrap_or_else(|| this.truncate(u128::MAX, dest.layout));
             this.write_scalar(Scalar::from_uint(n, dest.layout.size), dest)?;
             this.go_to_block(ret);
             return Ok(None);

tests/compile-fail/exact_div4.rs

@@ -1,5 +1,5 @@
 #![feature(core_intrinsics)]
 fn main() {
-    // divison of min_value by -1
-    unsafe { std::intrinsics::exact_div(i64::min_value(), -1); } //~ ERROR result of dividing MIN by -1 cannot be represented
+    // divison of MIN by -1
+    unsafe { std::intrinsics::exact_div(i64::MIN, -1); } //~ ERROR result of dividing MIN by -1 cannot be represented
 }

tests/compile-fail/ptr_offset_overflow.rs

@@ -2,5 +2,5 @@
 fn main() {
     let v = [1i8, 2];
     let x = &v[1] as *const i8;
-    let _val = unsafe { x.offset(isize::min_value()) };
+    let _val = unsafe { x.offset(isize::MIN) };
 }

tests/compile-fail/slice-too-big.rs

@@ -1,5 +1,4 @@
 use std::mem;
-use std::usize;
 
 fn main() { unsafe {
     let ptr = Box::into_raw(Box::new(0u8));

tests/compile-fail/unchecked_div1.rs

@@ -1,5 +1,5 @@
 #![feature(core_intrinsics)]
 fn main() {
     // MIN/-1 cannot be represented
-    unsafe { std::intrinsics::unchecked_div(i16::min_value(), -1); } //~ ERROR Overflow executing `unchecked_div`
+    unsafe { std::intrinsics::unchecked_div(i16::MIN, -1); } //~ ERROR Overflow executing `unchecked_div`
 }

tests/run-pass/align_offset.rs

@@ -5,15 +5,15 @@ fn test_align_offset() {
 
     assert_eq!(raw.align_offset(2), 0);
     assert_eq!(raw.align_offset(4), 0);
-    assert_eq!(raw.align_offset(8), usize::max_value()); // requested alignment higher than allocation alignment
+    assert_eq!(raw.align_offset(8), usize::MAX); // requested alignment higher than allocation alignment
 
     assert_eq!(raw.wrapping_offset(1).align_offset(2), 1);
     assert_eq!(raw.wrapping_offset(1).align_offset(4), 3);
-    assert_eq!(raw.wrapping_offset(1).align_offset(8), usize::max_value()); // requested alignment higher than allocation alignment
+    assert_eq!(raw.wrapping_offset(1).align_offset(8), usize::MAX); // requested alignment higher than allocation alignment
 
     assert_eq!(raw.wrapping_offset(2).align_offset(2), 0);
     assert_eq!(raw.wrapping_offset(2).align_offset(4), 2);
-    assert_eq!(raw.wrapping_offset(2).align_offset(8), usize::max_value()); // requested alignment higher than allocation alignment
+    assert_eq!(raw.wrapping_offset(2).align_offset(8), usize::MAX); // requested alignment higher than allocation alignment
 }
 
 fn test_align_to() {

tests/run-pass/integer-ops.rs

@@ -8,16 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::i32;
-
 pub fn main() {
     // This tests that do (not) do sign extension properly when loading integers
-    assert_eq!(u32::max_value() as i64, 4294967295);
-    assert_eq!(i32::min_value() as i64, -2147483648);
-
-    assert_eq!(i8::min_value(), -128);
+    assert_eq!(u32::MAX as i64, 4294967295);
+    assert_eq!(i32::MIN as i64, -2147483648);
 
-    assert_eq!(i8::max_value(), 127);
+    assert_eq!(i8::MAX, 127);
+    assert_eq!(i8::MIN, -128);
 
     assert_eq!(i32::from_str_radix("A", 16), Ok(10));