Clippy fixes for Rust 1.73.0 (#2347)

* Clippy fixes for Rust 1.73.0

* Doc fixes too

vulkano-macros/src/derive_buffer_contents.rs

@@ -23,11 +23,8 @@ pub fn derive_buffer_contents(mut ast: DeriveInput) -> Result<TokenStream> {
     if !ast
         .attrs
         .iter()
-        .filter_map(|attr| {
-            attr.path
-                .is_ident("repr")
-                .then(|| attr.parse_meta().unwrap())
-        })
+        .filter(|&attr| attr.path.is_ident("repr"))
+        .map(|attr| attr.parse_meta().unwrap())
         .any(|meta| match meta {
             Meta::List(MetaList { nested, .. }) => {
                 nested.iter().any(|nested_meta| match nested_meta {

vulkano-util/src/renderer.rs

@@ -50,7 +50,7 @@ pub struct VulkanoWindowRenderer {
 impl VulkanoWindowRenderer {
     /// Creates a new [`VulkanoWindowRenderer`] which is used to orchestrate your rendering with
     /// Vulkano. Pass [`WindowDescriptor`] and optionally a function modifying the
-    /// [`SwapchainCreateInfo`](vulkano::swapchain::SwapchainCreateInfo) parameters.
+    /// [`SwapchainCreateInfo`] parameters.
     pub fn new(
         vulkano_context: &VulkanoContext,
         window: winit::window::Window,
@@ -254,7 +254,7 @@ impl VulkanoWindowRenderer {
     }
 
     /// Begin your rendering by calling `acquire`.
-    /// Returns a [`GpuFuture`](vulkano::sync::GpuFuture) representing the time after which the
+    /// Returns a [`GpuFuture`] representing the time after which the
     /// swapchain image has been acquired and previous frame ended.
     /// Execute your command buffers after calling this function and finish rendering by calling
     /// [`VulkanoWindowRenderer::present`].

vulkano/autogen/extensions.rs

@@ -95,16 +95,26 @@ fn device_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
          }| {
             let name_string = name.to_string();
 
-            let dependency_check_items = requires_all_of.iter().filter_map(
-                |RequiresOneOf {
+            let dependency_check_items = requires_all_of
+                .iter()
+                .filter(
+                    |&RequiresOneOf {
                          api_version,
                          device_extensions,
                          instance_extensions,
                          features: _,
                      }| {
-                    (device_extensions.is_empty()
-                        && (api_version.is_some() || !instance_extensions.is_empty()))
-                    .then(|| {
+                        device_extensions.is_empty()
+                            && (api_version.is_some() || !instance_extensions.is_empty())
+                    },
+                )
+                .map(
+                    |RequiresOneOf {
+                         api_version,
+                         device_extensions: _,
+                         instance_extensions,
+                         features: _,
+                     }| {
                         let condition_items = (api_version.iter().map(|version| {
                             let version = format_ident!("V{}_{}", version.0, version.1);
                             quote! { api_version >= crate::Version::#version }
@@ -141,7 +151,6 @@ fn device_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
                                 }));
                             }
                         }
-                    })
                     },
                 );
             let problem = format!(
@@ -164,21 +173,38 @@ fn device_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
         },
     );
 
-    let enable_dependencies_items = members.iter().filter_map(
+    let enable_dependencies_items = members
+        .iter()
+        .filter(
+            |&ExtensionsMember {
+                 name: _,
+                 requires_all_of,
+                 ..
+             }| (!requires_all_of.is_empty()),
+        )
+        .map(
             |ExtensionsMember {
                  name,
                  requires_all_of,
                  ..
              }| {
-            (!requires_all_of.is_empty()).then(|| {
-                let requires_all_of_items = requires_all_of.iter().filter_map(
+                let requires_all_of_items = requires_all_of
+                    .iter()
+                    .filter(
+                        |&RequiresOneOf {
+                             api_version: _,
+                             device_extensions,
+                             instance_extensions: _,
+                             features: _,
+                         }| (!device_extensions.is_empty()),
+                    )
+                    .map(
                         |RequiresOneOf {
                              api_version,
                              device_extensions,
                              instance_extensions: _,
                              features: _,
                          }| {
-                        (!device_extensions.is_empty()).then(|| {
                             let condition_items = api_version
                                 .iter()
                                 .map(|(major, minor)| {
@@ -226,7 +252,6 @@ fn device_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
                                     }
                                 }
                             }
-                        })
                         },
                     );
 
@@ -235,7 +260,6 @@ fn device_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
                         #(#requires_all_of_items)*
                     }
                 }
-            })
             },
         );
 
@@ -325,21 +349,38 @@ fn instance_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
         },
     );
 
-    let enable_dependencies_items = members.iter().filter_map(
+    let enable_dependencies_items = members
+        .iter()
+        .filter(
+            |&ExtensionsMember {
+                 name: _,
+                 requires_all_of,
+                 ..
+             }| (!requires_all_of.is_empty()),
+        )
+        .map(
             |ExtensionsMember {
                  name,
                  requires_all_of,
                  ..
              }| {
-            (!requires_all_of.is_empty()).then(|| {
-                let requires_all_of_items = requires_all_of.iter().filter_map(
+                let requires_all_of_items = requires_all_of
+                    .iter()
+                    .filter(
+                        |&RequiresOneOf {
+                             api_version: _,
+                             device_extensions: _,
+                             instance_extensions,
+                             features: _,
+                         }| (!instance_extensions.is_empty()),
+                    )
+                    .map(
                         |RequiresOneOf {
                              api_version,
                              device_extensions: _,
                              instance_extensions,
                              features: _,
                          }| {
-                        (!instance_extensions.is_empty()).then(|| {
                             let condition_items = api_version
                                 .iter()
                                 .map(|(major, minor)| {
@@ -387,7 +428,6 @@ fn instance_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
                                     }
                                 }
                             }
-                        })
                         },
                     );
 
@@ -396,7 +436,6 @@ fn instance_extensions_output(members: &[ExtensionsMember]) -> TokenStream {
                         #(#requires_all_of_items)*
                     }
                 }
-            })
             },
         );
 

vulkano/autogen/formats.rs

@@ -170,16 +170,21 @@ fn formats_output(members: &[FormatMember]) -> TokenStream {
                 Some(quote! { Self::#name => &[#(Self::#planes),*], })
             }
         });
-    let texels_per_block_items = members.iter().filter_map(
+    let texels_per_block_items = members
+        .iter()
+        .filter(
+            |&FormatMember {
+                 texels_per_block, ..
+             }| (*texels_per_block != 1),
+        )
+        .map(
             |FormatMember {
                  name,
                  texels_per_block,
                  ..
              }| {
-            (*texels_per_block != 1).then(|| {
                 let texels_per_block = Literal::u8_unsuffixed(*texels_per_block);
                 quote! { Self::#name => #texels_per_block, }
-            })
             },
         );
     let numeric_format_color_items = members.iter().filter_map(

vulkano/src/library.rs

@@ -211,7 +211,7 @@ impl VulkanLibrary {
     /// Returns the list of layers that are available when creating an instance.
     ///
     /// On success, this function returns an iterator that produces
-    /// [`LayerProperties`](crate::instance::LayerProperties) objects. In order to enable a layer,
+    /// [`LayerProperties`] objects. In order to enable a layer,
     /// you need to pass its name (returned by `LayerProperties::name()`) when creating the
     /// [`Instance`](crate::instance::Instance).
     ///

vulkano/src/memory/alignment.rs

@@ -156,7 +156,7 @@ impl Hash for DeviceAlignment {
 impl PartialOrd for DeviceAlignment {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.as_nonzero().partial_cmp(&other.as_nonzero())
+        Some(self.cmp(other))
     }
 }