multiboot2: apply latest clippy code style guidelines

Author: phip1611

multiboot2/Changelog.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- **Breaking** All functions that returns something useful are now `#[must_use]`
 - updated dependencies
 - MSRV is 1.75
 - doc fixes

multiboot2/src/boot_information.rs

@@ -46,7 +46,7 @@ pub struct BootInformationHeader {
 
 #[cfg(feature = "builder")]
 impl BootInformationHeader {
-    pub(crate) fn new(total_size: u32) -> Self {
+    pub(crate) const fn new(total_size: u32) -> Self {
         Self {
             total_size,
             _reserved: 0,
@@ -140,12 +140,14 @@ impl<'a> BootInformation<'a> {
     }
 
     /// Get the start address of the boot info.
+    #[must_use]
     pub fn start_address(&self) -> usize {
         self.as_ptr() as usize
     }
 
     /// Get the start address of the boot info as pointer.
-    pub fn as_ptr(&self) -> *const () {
+    #[must_use]
+    pub const fn as_ptr(&self) -> *const () {
         core::ptr::addr_of!(*self.0).cast()
     }
 
@@ -159,12 +161,14 @@ impl<'a> BootInformation<'a> {
     /// # let boot_info = unsafe { BootInformation::load(ptr).unwrap() };
     /// let end_addr = boot_info.start_address() + boot_info.total_size();
     /// ```
+    #[must_use]
     pub fn end_address(&self) -> usize {
         self.start_address() + self.total_size()
     }
 
     /// Get the total size of the boot info struct.
-    pub fn total_size(&self) -> usize {
+    #[must_use]
+    pub const fn total_size(&self) -> usize {
         self.0.header.total_size as usize
     }
 
@@ -177,11 +181,13 @@ impl<'a> BootInformation<'a> {
     }*/
 
     /// Search for the basic memory info tag.
+    #[must_use]
     pub fn basic_memory_info_tag(&self) -> Option<&BasicMemoryInfoTag> {
         self.get_tag::<BasicMemoryInfoTag>()
     }
 
     /// Search for the BootLoader name tag.
+    #[must_use]
     pub fn boot_loader_name_tag(&self) -> Option<&BootLoaderNameTag> {
         self.get_tag::<BootLoaderNameTag>()
     }
@@ -192,11 +198,13 @@ impl<'a> BootInformation<'a> {
     }*/
 
     /// Search for the Command line tag.
+    #[must_use]
     pub fn command_line_tag(&self) -> Option<&CommandLineTag> {
         self.get_tag::<CommandLineTag>()
     }
 
     /// Search for the EFI boot services not exited tag.
+    #[must_use]
     pub fn efi_bs_not_exited_tag(&self) -> Option<&EFIBootServicesNotExitedTag> {
         self.get_tag::<EFIBootServicesNotExitedTag>()
     }
@@ -205,34 +213,37 @@ impl<'a> BootInformation<'a> {
     /// Otherwise, if the [`TagType::EfiBs`] tag is present, this returns `None`
     /// as it is strictly recommended to get the memory map from the `uefi`
     /// services.
+    #[must_use]
     pub fn efi_memory_map_tag(&self) -> Option<&EFIMemoryMapTag> {
         // If the EFIBootServicesNotExited is present, then we should not use
         // the memory map, as it could still be in use.
-        match self.get_tag::<EFIBootServicesNotExitedTag>() {
-            Some(_tag) => {
-                log::debug!("The EFI memory map is present but the UEFI Boot Services Not Existed Tag is present. Returning None.");
-                None
-            }
-            None => self.get_tag::<EFIMemoryMapTag>(),
-        }
+        self.get_tag::<EFIBootServicesNotExitedTag>().map_or_else(
+            || self.get_tag::<EFIMemoryMapTag>(), |_tag| {
+                            log::debug!("The EFI memory map is present but the UEFI Boot Services Not Existed Tag is present. Returning None.");
+                             None
+                        })
     }
 
     /// Search for the EFI 32-bit SDT tag.
+    #[must_use]
     pub fn efi_sdt32_tag(&self) -> Option<&EFISdt32Tag> {
         self.get_tag::<EFISdt32Tag>()
     }
 
     /// Search for the EFI 64-bit SDT tag.
+    #[must_use]
     pub fn efi_sdt64_tag(&self) -> Option<&EFISdt64Tag> {
         self.get_tag::<EFISdt64Tag>()
     }
 
     /// Search for the EFI 32-bit image handle pointer tag.
+    #[must_use]
     pub fn efi_ih32_tag(&self) -> Option<&EFIImageHandle32Tag> {
         self.get_tag::<EFIImageHandle32Tag>()
     }
 
     /// Search for the EFI 64-bit image handle pointer tag.
+    #[must_use]
     pub fn efi_ih64_tag(&self) -> Option<&EFIImageHandle64Tag> {
         self.get_tag::<EFIImageHandle64Tag>()
     }
@@ -254,6 +265,7 @@ impl<'a> BootInformation<'a> {
     ///     }
     /// }
     /// ```
+    #[must_use]
     pub fn elf_sections(&self) -> Option<ElfSectionIter> {
         let tag = self.get_tag::<ElfSectionsTag>();
         tag.map(|t| {
@@ -264,6 +276,7 @@ impl<'a> BootInformation<'a> {
 
     /// Search for the VBE framebuffer tag. The result is `Some(Err(e))`, if the
     /// framebuffer type is unknown, while the framebuffer tag is present.
+    #[must_use]
     pub fn framebuffer_tag(&self) -> Option<Result<&FramebufferTag, UnknownFramebufferType>> {
         self.get_tag::<FramebufferTag>()
             .map(|tag| match tag.buffer_type() {
@@ -273,16 +286,19 @@ impl<'a> BootInformation<'a> {
     }
 
     /// Search for the Image Load Base Physical Address tag.
+    #[must_use]
     pub fn load_base_addr_tag(&self) -> Option<&ImageLoadPhysAddrTag> {
         self.get_tag::<ImageLoadPhysAddrTag>()
     }
 
     /// Search for the Memory map tag.
+    #[must_use]
     pub fn memory_map_tag(&self) -> Option<&MemoryMapTag> {
         self.get_tag::<MemoryMapTag>()
     }
 
     /// Get an iterator of all module tags.
+    #[must_use]
     pub fn module_tags(&self) -> ModuleIter {
         module::module_iter(self.tags())
     }
@@ -293,21 +309,25 @@ impl<'a> BootInformation<'a> {
     }*/
 
     /// Search for the (ACPI 1.0) RSDP tag.
+    #[must_use]
     pub fn rsdp_v1_tag(&self) -> Option<&RsdpV1Tag> {
         self.get_tag::<RsdpV1Tag>()
     }
 
     /// Search for the (ACPI 2.0 or later) RSDP tag.
+    #[must_use]
     pub fn rsdp_v2_tag(&self) -> Option<&RsdpV2Tag> {
         self.get_tag::<RsdpV2Tag>()
     }
 
     /// Search for the SMBIOS tag.
+    #[must_use]
     pub fn smbios_tag(&self) -> Option<&SmbiosTag> {
         self.get_tag::<SmbiosTag>()
     }
 
     /// Search for the VBE information tag.
+    #[must_use]
     pub fn vbe_info_tag(&self) -> Option<&VBEInfoTag> {
         self.get_tag::<VBEInfoTag>()
     }
@@ -367,6 +387,7 @@ impl<'a> BootInformation<'a> {
     ///     .unwrap();
     /// assert_eq!(tag.name(), Ok("name"));
     /// ```
+    #[must_use]
     pub fn get_tag<TagT: TagTrait + ?Sized + 'a>(&'a self) -> Option<&'a TagT> {
         self.tags()
             .find(|tag| tag.typ == TagT::ID)

multiboot2/src/boot_loader_name.rs

@@ -20,6 +20,7 @@ pub struct BootLoaderNameTag {
 
 impl BootLoaderNameTag {
     #[cfg(feature = "builder")]
+    #[must_use]
     pub fn new(name: &str) -> BoxedDst<Self> {
         let mut bytes: Vec<_> = name.bytes().collect();
         if !bytes.ends_with(&[0]) {
@@ -100,7 +101,7 @@ mod tests {
         let tag = get_bytes();
         let tag = unsafe { &*tag.as_ptr().cast::<Tag>() };
         let tag = tag.cast_tag::<BootLoaderNameTag>();
-        assert_eq!({ tag.typ }, TagType::BootLoaderName);
+        assert_eq!(tag.header.typ, TagType::BootLoaderName);
         assert_eq!(tag.name().expect("must be valid UTF-8"), MSG);
     }
 

multiboot2/src/builder/boxed_dst.rs

@@ -144,7 +144,7 @@ mod tests {
 
     #[test]
     fn can_hold_tag_trait() {
-        fn consume<T: TagTrait + ?Sized>(_: &T) {}
+        const fn consume<T: TagTrait + ?Sized>(_: &T) {}
         let content = b"hallo\0";
 
         let tag = BoxedDst::<CustomTag>::new(content);

multiboot2/src/builder/information.rs

@@ -73,6 +73,7 @@ impl Default for InformationBuilder {
 
 impl InformationBuilder {
     /// Creates a new builder.
+    #[must_use]
     pub const fn new() -> Self {
         Self(Vec::new())
     }
@@ -87,6 +88,7 @@ impl InformationBuilder {
     /// [`Self::build`]-method is called. This function assumes that the begin
     /// of the boot information is 8-byte aligned and automatically adds padding
     /// between tags to ensure that each tag is 8-byte aligned.
+    #[must_use]
     pub fn expected_len(&self) -> usize {
         let tag_size_iter = self.0.iter().map(|(_, bytes)| bytes.len());
 
@@ -118,6 +120,7 @@ impl InformationBuilder {
     }
 
     /// Constructs the bytes for a valid Multiboot2 information with the given properties.
+    #[must_use]
     pub fn build(self) -> BootInformationBytes {
         const ALIGN: usize = 8;
 
@@ -202,92 +205,109 @@ impl InformationBuilder {
     }
 
     /// Adds a 'basic memory information' tag (represented by [`BasicMemoryInfoTag`]) to the builder.
+    #[must_use]
     pub fn basic_memory_info_tag(self, tag: BasicMemoryInfoTag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a 'bootloader name' tag (represented by [`BootLoaderNameTag`]) to the builder.
+    #[must_use]
     pub fn bootloader_name_tag(self, tag: BoxedDst<BootLoaderNameTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
     /// Adds a 'command line' tag (represented by [`CommandLineTag`]) to the builder.
+    #[must_use]
     pub fn command_line_tag(self, tag: BoxedDst<CommandLineTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
     /// Adds a 'EFI 32-bit system table pointer' tag (represented by [`EFISdt32Tag`]) to the builder.
+    #[must_use]
     pub fn efisdt32_tag(self, tag: EFISdt32Tag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a 'EFI 64-bit system table pointer' tag (represented by [`EFISdt64Tag`]) to the builder.
+    #[must_use]
     pub fn efisdt64_tag(self, tag: EFISdt64Tag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a 'EFI boot services not terminated' tag (represented by [`EFIBootServicesNotExitedTag`]) to the builder.
+    #[must_use]
     pub fn efi_boot_services_not_exited_tag(self) -> Self {
         self.add_tag(&EFIBootServicesNotExitedTag::new()).unwrap()
     }
 
     /// Adds a 'EFI 32-bit image handle pointer' tag (represented by [`EFIImageHandle32Tag`]) to the builder.
+    #[must_use]
     pub fn efi_image_handle32(self, tag: EFIImageHandle32Tag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a 'EFI 64-bit image handle pointer' tag (represented by [`EFIImageHandle64Tag`]) to the builder.
+    #[must_use]
     pub fn efi_image_handle64(self, tag: EFIImageHandle64Tag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a 'EFI Memory map' tag (represented by [`EFIMemoryMapTag`]) to the builder.
+    #[must_use]
     pub fn efi_memory_map_tag(self, tag: BoxedDst<EFIMemoryMapTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
     /// Adds a 'ELF-Symbols' tag (represented by [`ElfSectionsTag`]) to the builder.
+    #[must_use]
     pub fn elf_sections_tag(self, tag: BoxedDst<ElfSectionsTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
     /// Adds a 'Framebuffer info' tag (represented by [`FramebufferTag`]) to the builder.
+    #[must_use]
     pub fn framebuffer_tag(self, tag: BoxedDst<FramebufferTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
     /// Adds a 'Image load base physical address' tag (represented by [`ImageLoadPhysAddrTag`]) to the builder.
+    #[must_use]
     pub fn image_load_addr(self, tag: ImageLoadPhysAddrTag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a (*none EFI*) 'memory map' tag (represented by [`MemoryMapTag`]) to the builder.
+    #[must_use]
     pub fn memory_map_tag(self, tag: BoxedDst<MemoryMapTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
     /// Adds a 'Modules' tag (represented by [`ModuleTag`]) to the builder.
     /// This tag can occur multiple times in boot information.
+    #[must_use]
     pub fn add_module_tag(self, tag: BoxedDst<ModuleTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
     /// Adds a 'ACPI old RSDP' tag (represented by [`RsdpV1Tag`]) to the builder.
+    #[must_use]
     pub fn rsdp_v1_tag(self, tag: RsdpV1Tag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a 'ACPI new RSDP' tag (represented by [`RsdpV2Tag`]) to the builder.
+    #[must_use]
     pub fn rsdp_v2_tag(self, tag: RsdpV2Tag) -> Self {
         self.add_tag(&tag).unwrap()
     }
 
     /// Adds a 'SMBIOS tables' tag (represented by [`SmbiosTag`]) to the builder.
+    #[must_use]
     pub fn smbios_tag(self, tag: BoxedDst<SmbiosTag>) -> Self {
         self.add_tag(&*tag).unwrap()
     }
 
-    fn tag_is_allowed_multiple_times(tag_type: TagType) -> bool {
+    const fn tag_is_allowed_multiple_times(tag_type: TagType) -> bool {
         matches!(
             tag_type,
             TagType::Module | TagType::Smbios | TagType::Custom(_)

multiboot2/src/command_line.rs

@@ -8,7 +8,7 @@ use core::str;
 #[cfg(feature = "builder")]
 use {crate::builder::BoxedDst, alloc::vec::Vec};
 
-pub(crate) const METADATA_SIZE: usize = mem::size_of::<TagTypeId>() + mem::size_of::<u32>();
+pub const METADATA_SIZE: usize = mem::size_of::<TagTypeId>() + mem::size_of::<u32>();
 
 /// This tag contains the command line string.
 ///
@@ -25,6 +25,7 @@ pub struct CommandLineTag {
 impl CommandLineTag {
     /// Create a new command line tag from the given string.
     #[cfg(feature = "builder")]
+    #[must_use]
     pub fn new(command_line: &str) -> BoxedDst<Self> {
         let mut bytes: Vec<_> = command_line.bytes().collect();
         if !bytes.ends_with(&[0]) {
@@ -107,7 +108,7 @@ mod tests {
         let tag = get_bytes();
         let tag = unsafe { &*tag.as_ptr().cast::<Tag>() };
         let tag = tag.cast_tag::<CommandLineTag>();
-        assert_eq!({ tag.typ }, TagType::Cmdline);
+        assert_eq!(tag.header.typ, TagType::Cmdline);
         assert_eq!(tag.cmdline().expect("must be valid UTF-8"), MSG);
     }