clippy/uefi: prefer Self where possible

Author: phip1611

uefi/src/data_types/chars.rs

@@ -35,19 +35,19 @@ impl TryFrom<char> for Char8 {
 }
 
 impl From<Char8> for char {
-    fn from(char: Char8) -> char {
-        char::from(char.0)
+    fn from(char: Char8) -> Self {
+        Self::from(char.0)
     }
 }
 
 impl From<u8> for Char8 {
     fn from(value: u8) -> Self {
-        Char8(value)
+        Self(value)
     }
 }
 
 impl From<Char8> for u8 {
-    fn from(char: Char8) -> u8 {
+    fn from(char: Char8) -> Self {
         char.0
     }
 }
@@ -107,7 +107,7 @@ impl TryFrom<char> for Char16 {
 }
 
 impl From<Char16> for char {
-    fn from(char: Char16) -> char {
+    fn from(char: Char16) -> Self {
         u32::from(char.0).try_into().unwrap()
     }
 }
@@ -127,7 +127,7 @@ impl TryFrom<u16> for Char16 {
 }
 
 impl From<Char16> for u16 {
-    fn from(char: Char16) -> u16 {
+    fn from(char: Char16) -> Self {
         char.0
     }
 }

uefi/src/data_types/owned_strs.rs

@@ -113,7 +113,7 @@ impl CString16 {
 
 impl Default for CString16 {
     fn default() -> Self {
-        CString16::new()
+        Self::new()
     }
 }
 
@@ -141,7 +141,7 @@ impl TryFrom<&str> for CString16 {
         // Add trailing nul.
         output.push(NUL_16);
 
-        Ok(CString16(output))
+        Ok(Self(output))
     }
 }
 
@@ -175,7 +175,7 @@ impl<'a> TryFrom<&UnalignedSlice<'a, u16>> for CString16 {
 
     fn try_from(input: &UnalignedSlice<u16>) -> Result<Self, Self::Error> {
         let v = input.to_vec();
-        CString16::try_from(v)
+        Self::try_from(v)
     }
 }
 
@@ -189,7 +189,7 @@ impl From<&CStr16> for CString16 {
 impl From<&CString16> for String {
     fn from(value: &CString16) -> Self {
         let slice: &CStr16 = value.as_ref();
-        String::from(slice)
+        Self::from(slice)
     }
 }
 

uefi/src/data_types/strs.rs

@@ -457,7 +457,7 @@ impl CStr16 {
     pub fn from_unaligned_slice<'buf>(
         src: &UnalignedSlice<'_, u16>,
         buf: &'buf mut [MaybeUninit<u16>],
-    ) -> Result<&'buf CStr16, UnalignedCStr16Error> {
+    ) -> Result<&'buf Self, UnalignedCStr16Error> {
         // The input `buf` might be longer than needed, so get a
         // subslice of the required length.
         let buf = buf
@@ -469,7 +469,7 @@ impl CStr16 {
             // Safety: `copy_buf` fully initializes the slice.
             maybe_uninit_slice_assume_init_ref(buf)
         };
-        CStr16::from_u16_with_nul(buf).map_err(|e| match e {
+        Self::from_u16_with_nul(buf).map_err(|e| match e {
             FromSliceWithNulError::InvalidChar(v) => UnalignedCStr16Error::InvalidChar(v),
             FromSliceWithNulError::InteriorNul(v) => UnalignedCStr16Error::InteriorNul(v),
             FromSliceWithNulError::NotNulTerminated => UnalignedCStr16Error::NotNulTerminated,
@@ -593,7 +593,7 @@ impl From<&CStr16> for alloc::string::String {
             .map(u16::from)
             .map(u32::from)
             .map(|int| char::from_u32(int).expect("Should be encodable as UTF-8"))
-            .collect::<alloc::string::String>()
+            .collect::<Self>()
     }
 }
 
@@ -615,8 +615,8 @@ impl<StrType: AsRef<str> + ?Sized> EqStrUntilNul<StrType> for CStr16 {
     }
 }
 
-impl AsRef<CStr16> for CStr16 {
-    fn as_ref(&self) -> &CStr16 {
+impl AsRef<Self> for CStr16 {
+    fn as_ref(&self) -> &Self {
         self
     }
 }

uefi/src/helpers/logger.rs

@@ -58,7 +58,7 @@ impl core::fmt::Write for DebugconWriter {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         for &byte in s.as_bytes() {
             unsafe {
-                core::arch::asm!("outb %al, %dx", in("al") byte, in("dx") DebugconWriter::IO_PORT, options(att_syntax))
+                core::arch::asm!("outb %al, %dx", in("al") byte, in("dx") Self::IO_PORT, options(att_syntax))
             };
         }
         Ok(())
@@ -83,7 +83,7 @@ impl Logger {
     /// [`set_output`]: Self::set_output
     #[must_use]
     pub const fn new() -> Self {
-        Logger {
+        Self {
             writer: AtomicPtr::new(ptr::null_mut()),
         }
     }

uefi/src/lib.rs

@@ -89,8 +89,11 @@
 #![no_std]
 // Enable some additional warnings and lints.
 #![warn(clippy::ptr_as_ptr, missing_docs, unused)]
-#![deny(clippy::all)]
-#![deny(clippy::must_use_candidate)]
+#![deny(
+    clippy::all,
+    clippy::must_use_candidate,
+    clippy::use_self
+)]
 #![deny(missing_debug_implementations)]
 
 #[cfg(feature = "alloc")]

uefi/src/mem/memory_map/impl_.rs

@@ -373,7 +373,7 @@ impl MemoryMapOwned {
     pub(crate) fn from_initialized_mem(buf: MemoryMapBackingMemory, meta: MemoryMapMeta) -> Self {
         assert!(meta.desc_size >= mem::size_of::<MemoryDescriptor>());
         let len = meta.entry_count();
-        MemoryMapOwned { buf, meta, len }
+        Self { buf, meta, len }
     }
 }
 

uefi/src/proto/console/text/input.rs

@@ -98,11 +98,11 @@ pub enum Key {
 }
 
 impl From<InputKey> for Key {
-    fn from(k: InputKey) -> Key {
+    fn from(k: InputKey) -> Self {
         if k.scan_code == ScanCode::NULL.0 {
-            Key::Printable(Char16::try_from(k.unicode_char).unwrap())
+            Self::Printable(Char16::try_from(k.unicode_char).unwrap())
         } else {
-            Key::Special(ScanCode(k.scan_code))
+            Self::Special(ScanCode(k.scan_code))
         }
     }
 }

uefi/src/proto/debug/exception.rs

@@ -5,27 +5,27 @@ pub struct ExceptionType(isize);
 
 impl ExceptionType {
     /// Undefined Exception
-    pub const EXCEPT_EBC_UNDEFINED: ExceptionType = ExceptionType(0);
+    pub const EXCEPT_EBC_UNDEFINED: Self = Self(0);
     /// Divide-by-zero Error
-    pub const EXCEPT_EBC_DIVIDE_ERROR: ExceptionType = ExceptionType(1);
+    pub const EXCEPT_EBC_DIVIDE_ERROR: Self = Self(1);
     /// Debug Exception
-    pub const EXCEPT_EBC_DEBUG: ExceptionType = ExceptionType(2);
+    pub const EXCEPT_EBC_DEBUG: Self = Self(2);
     /// Breakpoint
-    pub const EXCEPT_EBC_BREAKPOINT: ExceptionType = ExceptionType(3);
+    pub const EXCEPT_EBC_BREAKPOINT: Self = Self(3);
     /// Overflow
-    pub const EXCEPT_EBC_OVERFLOW: ExceptionType = ExceptionType(4);
+    pub const EXCEPT_EBC_OVERFLOW: Self = Self(4);
     /// Invalid Opcode
-    pub const EXCEPT_EBC_INVALID_OPCODE: ExceptionType = ExceptionType(5);
+    pub const EXCEPT_EBC_INVALID_OPCODE: Self = Self(5);
     /// Stack-Segment Fault
-    pub const EXCEPT_EBC_STACK_FAULT: ExceptionType = ExceptionType(6);
+    pub const EXCEPT_EBC_STACK_FAULT: Self = Self(6);
     /// Alignment Check
-    pub const EXCEPT_EBC_ALIGNMENT_CHECK: ExceptionType = ExceptionType(7);
+    pub const EXCEPT_EBC_ALIGNMENT_CHECK: Self = Self(7);
     /// Instruction Encoding Exception
-    pub const EXCEPT_EBC_INSTRUCTION_ENCODING: ExceptionType = ExceptionType(8);
+    pub const EXCEPT_EBC_INSTRUCTION_ENCODING: Self = Self(8);
     /// Bad Breakpoint Exception
-    pub const EXCEPT_EBC_BAD_BREAK: ExceptionType = ExceptionType(9);
+    pub const EXCEPT_EBC_BAD_BREAK: Self = Self(9);
     /// Single Step Exception
-    pub const EXCEPT_EBC_SINGLE_STEP: ExceptionType = ExceptionType(10);
+    pub const EXCEPT_EBC_SINGLE_STEP: Self = Self(10);
 }
 
 #[cfg(target_arch = "x86")]
@@ -69,39 +69,39 @@ impl ExceptionType {
 #[cfg(target_arch = "x86_64")]
 impl ExceptionType {
     /// Divide-by-zero Error
-    pub const EXCEPT_X64_DIVIDE_ERROR: ExceptionType = ExceptionType(0);
+    pub const EXCEPT_X64_DIVIDE_ERROR: Self = Self(0);
     /// Debug Exception
-    pub const EXCEPT_X64_DEBUG: ExceptionType = ExceptionType(1);
+    pub const EXCEPT_X64_DEBUG: Self = Self(1);
     /// Non-maskable Interrupt
-    pub const EXCEPT_X64_NMI: ExceptionType = ExceptionType(2);
+    pub const EXCEPT_X64_NMI: Self = Self(2);
     /// Breakpoint
-    pub const EXCEPT_X64_BREAKPOINT: ExceptionType = ExceptionType(3);
+    pub const EXCEPT_X64_BREAKPOINT: Self = Self(3);
     /// Overflow
-    pub const EXCEPT_X64_OVERFLOW: ExceptionType = ExceptionType(4);
+    pub const EXCEPT_X64_OVERFLOW: Self = Self(4);
     /// Bound Range Exceeded
-    pub const EXCEPT_X64_BOUND: ExceptionType = ExceptionType(5);
+    pub const EXCEPT_X64_BOUND: Self = Self(5);
     /// Invalid Opcode
-    pub const EXCEPT_X64_INVALID_OPCODE: ExceptionType = ExceptionType(6);
+    pub const EXCEPT_X64_INVALID_OPCODE: Self = Self(6);
     /// Double Fault
-    pub const EXCEPT_X64_DOUBLE_FAULT: ExceptionType = ExceptionType(8);
+    pub const EXCEPT_X64_DOUBLE_FAULT: Self = Self(8);
     /// Invalid TSS
-    pub const EXCEPT_X64_INVALID_TSS: ExceptionType = ExceptionType(10);
+    pub const EXCEPT_X64_INVALID_TSS: Self = Self(10);
     /// Segment Not Present
-    pub const EXCEPT_X64_SEG_NOT_PRESENT: ExceptionType = ExceptionType(11);
+    pub const EXCEPT_X64_SEG_NOT_PRESENT: Self = Self(11);
     /// Stack-Segment Fault
-    pub const EXCEPT_X64_STACK_FAULT: ExceptionType = ExceptionType(12);
+    pub const EXCEPT_X64_STACK_FAULT: Self = Self(12);
     /// General Protection Fault
-    pub const EXCEPT_X64_GP_FAULT: ExceptionType = ExceptionType(13);
+    pub const EXCEPT_X64_GP_FAULT: Self = Self(13);
     /// Page Fault
-    pub const EXCEPT_X64_PAGE_FAULT: ExceptionType = ExceptionType(14);
+    pub const EXCEPT_X64_PAGE_FAULT: Self = Self(14);
     /// x87 Floating-Point Exception
-    pub const EXCEPT_X64_FP_ERROR: ExceptionType = ExceptionType(16);
+    pub const EXCEPT_X64_FP_ERROR: Self = Self(16);
     /// Alignment Check
-    pub const EXCEPT_X64_ALIGNMENT_CHECK: ExceptionType = ExceptionType(17);
+    pub const EXCEPT_X64_ALIGNMENT_CHECK: Self = Self(17);
     /// Machine Check
-    pub const EXCEPT_X64_MACHINE_CHECK: ExceptionType = ExceptionType(18);
+    pub const EXCEPT_X64_MACHINE_CHECK: Self = Self(18);
     /// SIMD Floating-Point Exception
-    pub const EXCEPT_X64_SIMD: ExceptionType = ExceptionType(19);
+    pub const EXCEPT_X64_SIMD: Self = Self(19);
 }
 
 #[cfg(target_arch = "arm")]