chore: appease clippy

Signed-off-by: Patrick Roy <[email protected]>

Author: roypat

src/address.rs

@@ -12,11 +12,11 @@
 //!
 //! Two traits are defined to represent an address within an address space:
 //! - [`AddressValue`](trait.AddressValue.html): stores the raw value of an address. Typically
-//! `u32`,`u64` or `usize` is used to store the raw value. But pointers, such as `*u8`, can't be used
-//! because they don't implement the [`Add`](https://doc.rust-lang.org/std/ops/trait.Add.html) and
-//! [`Sub`](https://doc.rust-lang.org/std/ops/trait.Sub.html) traits.
+//!   `u32`,`u64` or `usize` is used to store the raw value. But pointers, such as `*u8`, can't be used
+//!   because they don't implement the [`Add`](https://doc.rust-lang.org/std/ops/trait.Add.html) and
+//!   [`Sub`](https://doc.rust-lang.org/std/ops/trait.Sub.html) traits.
 //! - [Address](trait.Address.html): encapsulates an [`AddressValue`](trait.AddressValue.html)
-//! object and defines methods to access and manipulate it.
+//!   object and defines methods to access and manipulate it.
 
 use std::cmp::{Eq, Ord, PartialEq, PartialOrd};
 use std::fmt::Debug;
@@ -243,7 +243,7 @@ mod tests {
     #[test]
     fn test_new() {
         assert_eq!(MockAddress::new(0), MockAddress(0));
-        assert_eq!(MockAddress::new(std::u64::MAX), MockAddress(std::u64::MAX));
+        assert_eq!(MockAddress::new(u64::MAX), MockAddress(u64::MAX));
     }
 
     #[test]
@@ -285,7 +285,7 @@ mod tests {
             Some(MockAddress(0x130))
         );
         assert_eq!(
-            MockAddress::new(std::u64::MAX - 0x3fff).checked_align_up(0x10000),
+            MockAddress::new(u64::MAX - 0x3fff).checked_align_up(0x10000),
             None
         );
     }
@@ -343,10 +343,10 @@ mod tests {
         // normal case
         check_add(10, 10, false, 20);
         // edge case
-        check_add(std::u64::MAX - 1, 1, false, std::u64::MAX);
+        check_add(u64::MAX - 1, 1, false, u64::MAX);
 
         // with overflow
-        check_add(std::u64::MAX, 1, true, 0);
+        check_add(u64::MAX, 1, true, 0);
     }
 
     fn check_sub(a: u64, b: u64, expected_overflow: bool, expected_result: u64) {
@@ -384,7 +384,7 @@ mod tests {
         check_sub(1, 1, false, 0);
 
         // with underflow
-        check_sub(0, 1, true, std::u64::MAX);
+        check_sub(0, 1, true, u64::MAX);
     }
 
     #[test]

src/bytes.rs

@@ -527,11 +527,11 @@ pub(crate) mod tests {
     fn test_bytes() {
         let bytes = MockBytesContainer::new();
 
-        assert!(bytes.write_obj(std::u64::MAX, 0).is_ok());
-        assert_eq!(bytes.read_obj::<u64>(0).unwrap(), std::u64::MAX);
+        assert!(bytes.write_obj(u64::MAX, 0).is_ok());
+        assert_eq!(bytes.read_obj::<u64>(0).unwrap(), u64::MAX);
 
         assert!(bytes
-            .write_obj(std::u64::MAX, MOCK_BYTES_CONTAINER_SIZE)
+            .write_obj(u64::MAX, MOCK_BYTES_CONTAINER_SIZE)
             .is_err());
         assert!(bytes.read_obj::<u64>(MOCK_BYTES_CONTAINER_SIZE).is_err());
     }

src/guest_memory.rs

@@ -19,12 +19,12 @@
 //! Traits and Structs
 //! - [`GuestAddress`](struct.GuestAddress.html): represents a guest physical address (GPA).
 //! - [`MemoryRegionAddress`](struct.MemoryRegionAddress.html): represents an offset inside a
-//! region.
+//!   region.
 //! - [`GuestMemoryRegion`](trait.GuestMemoryRegion.html): represent a continuous region of guest's
-//! physical memory.
+//!   physical memory.
 //! - [`GuestMemory`](trait.GuestMemory.html): represent a collection of `GuestMemoryRegion`
-//! objects.
-//! The main responsibilities of the `GuestMemory` trait are:
+//!   objects.
+//!   The main responsibilities of the `GuestMemory` trait are:
 //!     - hide the detail of accessing guest's physical address.
 //!     - map a request address to a `GuestMemoryRegion` object and relay the request to it.
 //!     - handle cases where an access request spanning two or more `GuestMemoryRegion` objects.
@@ -514,7 +514,7 @@ pub trait GuestMemory {
     ///
     /// * Compute the total size of all memory mappings in KB by iterating over the memory regions
     ///   and dividing their sizes to 1024, then summing up the values in an accumulator. (uses the
-    ///  `backend-mmap` feature)
+    ///   `backend-mmap` feature)
     ///
     /// ```
     /// # #[cfg(feature = "backend-mmap")]
@@ -550,7 +550,7 @@ pub trait GuestMemory {
     ///
     /// * Compute the total size of all memory mappings in KB by iterating over the memory regions
     ///   and dividing their sizes to 1024, then summing up the values in an accumulator. (uses the
-    ///  `backend-mmap` feature)
+    ///   `backend-mmap` feature)
     ///
     /// ```
     /// # #[cfg(feature = "backend-mmap")]

src/mmap.rs

@@ -951,7 +951,7 @@ mod tests {
         ])
         .unwrap();
 
-        let guest_mem_list = vec![guest_mem, guest_mem_backed_by_file];
+        let guest_mem_list = [guest_mem, guest_mem_backed_by_file];
         for guest_mem in guest_mem_list.iter() {
             assert!(guest_mem.address_in_range(GuestAddress(0x200)));
             assert!(!guest_mem.address_in_range(GuestAddress(0x600)));
@@ -977,7 +977,7 @@ mod tests {
         ])
         .unwrap();
 
-        let guest_mem_list = vec![guest_mem, guest_mem_backed_by_file];
+        let guest_mem_list = [guest_mem, guest_mem_backed_by_file];
         for guest_mem in guest_mem_list.iter() {
             assert_eq!(
                 guest_mem.check_address(GuestAddress(0x200)),
@@ -1009,7 +1009,7 @@ mod tests {
         ])
         .unwrap();
 
-        let guest_mem_list = vec![guest_mem, guest_mem_backed_by_file];
+        let guest_mem_list = [guest_mem, guest_mem_backed_by_file];
         for guest_mem in guest_mem_list.iter() {
             assert!(guest_mem.to_region_addr(GuestAddress(0x600)).is_none());
             let (r0, addr0) = guest_mem.to_region_addr(GuestAddress(0x800)).unwrap();
@@ -1037,7 +1037,7 @@ mod tests {
         ])
         .unwrap();
 
-        let guest_mem_list = vec![guest_mem, guest_mem_backed_by_file];
+        let guest_mem_list = [guest_mem, guest_mem_backed_by_file];
         for guest_mem in guest_mem_list.iter() {
             assert!(guest_mem.get_host_address(GuestAddress(0x600)).is_err());
             let ptr0 = guest_mem.get_host_address(GuestAddress(0x800)).unwrap();
@@ -1064,7 +1064,7 @@ mod tests {
         )])
         .unwrap();
 
-        let guest_mem_list = vec![guest_mem, guest_mem_backed_by_file];
+        let guest_mem_list = [guest_mem, guest_mem_backed_by_file];
         for guest_mem in guest_mem_list.iter() {
             let sample_buf = &[1, 2, 3, 4, 5];
 
@@ -1102,7 +1102,7 @@ mod tests {
         ])
         .unwrap();
 
-        let gm_list = vec![gm, gm_backed_by_file];
+        let gm_list = [gm, gm_backed_by_file];
         for gm in gm_list.iter() {
             let val1: u64 = 0xaa55_aa55_aa55_aa55;
             let val2: u64 = 0x55aa_55aa_55aa_55aa;
@@ -1142,7 +1142,7 @@ mod tests {
         )])
         .unwrap();
 
-        let gm_list = vec![gm, gm_backed_by_file];
+        let gm_list = [gm, gm_backed_by_file];
         for gm in gm_list.iter() {
             let sample_buf = &[1, 2, 3, 4, 5];
 
@@ -1173,7 +1173,7 @@ mod tests {
         )])
         .unwrap();
 
-        let gm_list = vec![gm, gm_backed_by_file];
+        let gm_list = [gm, gm_backed_by_file];
         for gm in gm_list.iter() {
             let addr = GuestAddress(0x1010);
             let mut file = if cfg!(unix) {
@@ -1276,7 +1276,7 @@ mod tests {
         ])
         .unwrap();
 
-        let gm_list = vec![gm, gm_backed_by_file];
+        let gm_list = [gm, gm_backed_by_file];
         for gm in gm_list.iter() {
             let sample_buf = &[1, 2, 3, 4, 5];
             assert_eq!(gm.write(sample_buf, GuestAddress(0xffc)).unwrap(), 5);
@@ -1489,7 +1489,7 @@ mod tests {
             Some(GuestAddress(0xfff))
         );
         assert_eq!(guest_mem.checked_offset(start_addr2, 0xc00), None);
-        assert_eq!(guest_mem.checked_offset(start_addr1, std::usize::MAX), None);
+        assert_eq!(guest_mem.checked_offset(start_addr1, usize::MAX), None);
 
         assert_eq!(guest_mem.checked_offset(start_addr1, 0x400), None);
         assert_eq!(
@@ -1518,7 +1518,7 @@ mod tests {
         assert!(guest_mem.check_range(start_addr2, 0x800));
         assert!(!guest_mem.check_range(start_addr2, 0x801));
         assert!(!guest_mem.check_range(start_addr2, 0xc00));
-        assert!(!guest_mem.check_range(start_addr1, std::usize::MAX));
+        assert!(!guest_mem.check_range(start_addr1, usize::MAX));
     }
 
     #[test]

src/mmap_unix.rs

@@ -461,7 +461,7 @@ mod tests {
         pub fn raw_os_error(&self) -> i32 {
             match self {
                 Error::Mmap(e) => e.raw_os_error().unwrap(),
-                _ => std::i32::MIN,
+                _ => i32::MIN,
             }
         }
     }
@@ -552,7 +552,7 @@ mod tests {
 
         // Offset + size will overflow.
         let r = MmapRegion::build(
-            Some(FileOffset::from_arc(a.clone(), std::u64::MAX)),
+            Some(FileOffset::from_arc(a.clone(), u64::MAX)),
             size,
             prot,
             flags,

src/mmap_xen.rs

@@ -1036,7 +1036,7 @@ mod tests {
         fn raw_os_error(&self) -> i32 {
             match self {
                 Error::Mmap(e) => e.raw_os_error().unwrap(),
-                _ => std::i32::MIN,
+                _ => i32::MIN,
             }
         }
     }

src/volatile_memory.rs

@@ -18,10 +18,10 @@
 //! For the purposes of maintaining safety, volatile memory has some rules of its own:
 //! 1. No references or slices to volatile memory (`&` or `&mut`).
 //! 2. Access should always been done with a volatile read or write.
-//! The First rule is because having references of any kind to memory considered volatile would
-//! violate pointer aliasing. The second is because unvolatile accesses are inherently undefined if
-//! done concurrently without synchronization. With volatile access we know that the compiler has
-//! not reordered or elided the access.
+//!    The First rule is because having references of any kind to memory considered volatile would
+//!    violate pointer aliasing. The second is because unvolatile accesses are inherently undefined if
+//!    done concurrently without synchronization. With volatile access we know that the compiler has
+//!    not reordered or elided the access.
 
 use std::cmp::min;
 use std::io::{self, Read, Write};
@@ -31,7 +31,6 @@ use std::ptr::copy;
 use std::ptr::{read_volatile, write_volatile};
 use std::result;
 use std::sync::atomic::Ordering;
-use std::usize;
 
 use crate::atomic_integer::AtomicInteger;
 use crate::bitmap::{Bitmap, BitmapSlice, BS};
@@ -1889,8 +1888,8 @@ mod tests {
         assert!(slice.subslice(101, 0).is_err());
         assert!(slice.subslice(101, 1).is_err());
 
-        assert!(slice.subslice(std::usize::MAX, 2).is_err());
-        assert!(slice.subslice(2, std::usize::MAX).is_err());
+        assert!(slice.subslice(usize::MAX, 2).is_err());
+        assert!(slice.subslice(2, usize::MAX).is_err());
 
         let maybe_offset_slice = slice.subslice(10, 80);
         assert!(maybe_offset_slice.is_ok());
@@ -1998,14 +1997,13 @@ mod tests {
 
     #[test]
     fn slice_overflow_error() {
-        use std::usize::MAX;
         let mut backing = vec![0u8];
         let a = VolatileSlice::from(backing.as_mut_slice());
-        let res = a.get_slice(MAX, 1).unwrap_err();
+        let res = a.get_slice(usize::MAX, 1).unwrap_err();
         assert_matches!(
             res,
             Error::Overflow {
-                base: MAX,
+                base: usize::MAX,
                 offset: 1,
             }
         );
@@ -2022,14 +2020,13 @@ mod tests {
 
     #[test]
     fn ref_overflow_error() {
-        use std::usize::MAX;
         let mut backing = vec![0u8];
         let a = VolatileSlice::from(backing.as_mut_slice());
-        let res = a.get_ref::<u8>(MAX).unwrap_err();
+        let res = a.get_ref::<u8>(usize::MAX).unwrap_err();
         assert_matches!(
             res,
             Error::Overflow {
-                base: MAX,
+                base: usize::MAX,
                 offset: 1,
             }
         );
@@ -2104,11 +2101,11 @@ mod tests {
         let a = VolatileSlice::from(backing.as_mut_slice());
         let s = a.as_volatile_slice();
         assert!(s.write_obj(55u16, 4).is_err());
-        assert!(s.write_obj(55u16, core::usize::MAX).is_err());
+        assert!(s.write_obj(55u16, usize::MAX).is_err());
         assert!(s.write_obj(55u16, 2).is_ok());
         assert_eq!(s.read_obj::<u16>(2).unwrap(), 55u16);
         assert!(s.read_obj::<u16>(4).is_err());
-        assert!(s.read_obj::<u16>(core::usize::MAX).is_err());
+        assert!(s.read_obj::<u16>(usize::MAX).is_err());
     }
 
     #[test]