clippy: apply latest fixes

Author: phip1611

uefi-macros/src/lib.rs

@@ -69,13 +69,10 @@ pub fn unsafe_protocol(args: TokenStream, input: TokenStream) -> TokenStream {
             quote!(::uefi::guid!(#lit))
         }
         Expr::Path(ExprPath { path, .. }) => quote!(#path),
-        _ => {
-            return err!(
-                expr,
-                "macro input must be either a string literal or path to a constant"
-            )
-            .into();
-        }
+        _ => err!(
+            expr,
+            "macro input must be either a string literal or path to a constant"
+        ),
     };
 
     let item_struct = parse_macro_input!(input as ItemStruct);

uefi/src/data_types/strs.rs

@@ -993,10 +993,10 @@ mod tests {
     fn test_unaligned_cstr16() {
         let mut buf = [0u16; 6];
         let us = unsafe {
-            let ptr = buf.as_mut_ptr() as *mut u8;
+            let ptr = buf.as_mut_ptr().cast::<u8>();
             // Intentionally create an unaligned u16 pointer. This
             // leaves room for five u16 characters.
-            let ptr = ptr.add(1) as *mut u16;
+            let ptr = ptr.add(1).cast::<u16>();
             // Write out the "test" string.
             ptr.add(0).write_unaligned(b't'.into());
             ptr.add(1).write_unaligned(b'e'.into());

uefi/src/mem/aligned_buffer.rs

@@ -112,7 +112,7 @@ mod tests {
     #[test]
     fn test_allocation_alignment() {
         for request_alignment in [1, 2, 4, 8, 16, 32, 64, 128] {
-            for request_len in [1 as usize, 32, 64, 128, 1024] {
+            for request_len in [1_usize, 32, 64, 128, 1024] {
                 let buffer =
                     AlignedBuffer::from_size_align(request_len, request_alignment).unwrap();
                 assert_eq!(buffer.ptr() as usize % request_alignment, 0);

uefi/src/mem/memory_map/impl_.rs

@@ -461,13 +461,13 @@ mod tests {
     ];
 
     /// Returns a copy of [`BASE_MMAP_UNSORTED`] owned on the stack.
-    fn new_mmap_memory() -> [MemoryDescriptor; 3] {
+    const fn new_mmap_memory() -> [MemoryDescriptor; 3] {
         BASE_MMAP_UNSORTED
     }
 
     fn mmap_raw<'a>(memory: &mut [MemoryDescriptor]) -> (&'a mut [u8], MemoryMapMeta) {
         let desc_size = size_of::<MemoryDescriptor>();
-        let len = memory.len() * desc_size;
+        let len = core::mem::size_of_val(memory);
         let ptr = memory.as_mut_ptr().cast::<u8>();
         let slice = unsafe { core::slice::from_raw_parts_mut(ptr, len) };
         let meta = MemoryMapMeta {

uefi/src/mem/memory_map/mod.rs

@@ -110,7 +110,7 @@ mod tests_mmap_artificial {
     fn buffer_to_map(buffer: &mut [MemoryDescriptor]) -> MemoryMapRefMut {
         let mmap_len = size_of_val(buffer);
         let mmap = {
-            unsafe { core::slice::from_raw_parts_mut(buffer.as_mut_ptr() as *mut u8, mmap_len) }
+            unsafe { core::slice::from_raw_parts_mut(buffer.as_mut_ptr().cast::<u8>(), mmap_len) }
         };
 
         MemoryMapRefMut::new(

uefi/src/polyfill.rs

@@ -18,7 +18,7 @@ pub const unsafe fn maybe_uninit_slice_assume_init_ref<T>(s: &[MaybeUninit<T>])
 /// Polyfill for the unstable `MaybeUninit::slice_as_mut_ptr` function.
 ///
 /// See <https://github.com/rust-lang/rust/issues/63569>.
-pub fn maybe_uninit_slice_as_mut_ptr<T>(s: &mut [MaybeUninit<T>]) -> *mut T {
+pub const fn maybe_uninit_slice_as_mut_ptr<T>(s: &mut [MaybeUninit<T>]) -> *mut T {
     s.as_mut_ptr().cast::<T>()
 }
 

uefi/src/proto/ata/mod.rs

@@ -294,7 +294,7 @@ impl<'a> AtaResponse<'a> {
     /// # Returns
     /// A reference to the [`AtaStatusBlock`] containing details about the status of the executed operation.
     #[must_use]
-    pub fn status(&self) -> &'a AtaStatusBlock {
+    pub const fn status(&self) -> &'a AtaStatusBlock {
         unsafe {
             self.req
                 .asb
@@ -310,7 +310,7 @@ impl<'a> AtaResponse<'a> {
     /// # Returns
     /// `Option<&[u8]>`: A slice of the data read from the device, or `None` if no read buffer was used.
     #[must_use]
-    pub fn read_buffer(&self) -> Option<&'a [u8]> {
+    pub const fn read_buffer(&self) -> Option<&'a [u8]> {
         if self.req.packet.in_data_buffer.is_null() {
             return None;
         }

uefi/src/proto/boot_policy.rs

@@ -51,14 +51,8 @@ mod tests {
 
     #[test]
     fn boot_policy() {
-        assert_eq!(
-            BootPolicy::try_from(Boolean::TRUE).unwrap(),
-            BootPolicy::BootSelection
-        );
-        assert_eq!(
-            BootPolicy::try_from(Boolean::FALSE).unwrap(),
-            BootPolicy::ExactMatch
-        );
+        assert_eq!(BootPolicy::from(Boolean::TRUE), BootPolicy::BootSelection);
+        assert_eq!(BootPolicy::from(Boolean::FALSE), BootPolicy::ExactMatch);
         assert_eq!(Boolean::from(BootPolicy::BootSelection), Boolean::TRUE);
         assert_eq!(Boolean::from(BootPolicy::ExactMatch), Boolean::FALSE);
     }

uefi/src/proto/device_path/build.rs

@@ -248,7 +248,7 @@ mod tests {
     };
     use core::slice;
 
-    fn path_to_bytes(path: &DevicePath) -> &[u8] {
+    const fn path_to_bytes(path: &DevicePath) -> &[u8] {
         unsafe { slice::from_raw_parts(path.as_ffi_ptr().cast::<u8>(), size_of_val(path)) }
     }
 

uefi/src/proto/loaded_image.rs

@@ -95,7 +95,7 @@ impl LoadedImage {
     ///
     /// [`load_options_as_cstr16`]: `Self::load_options_as_cstr16`
     #[must_use]
-    pub fn load_options_as_bytes(&self) -> Option<&[u8]> {
+    pub const fn load_options_as_bytes(&self) -> Option<&[u8]> {
         if self.0.load_options.is_null() {
             None
         } else {