Simplify error checking with .result()? and .result_with_success()

ash/src/device.rs

@@ -904,10 +904,7 @@ pub trait DeviceV1_0 {
         );
 
         desc_set.set_len(create_info.descriptor_set_count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(desc_set),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(desc_set)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorSetLayout.html>"]
@@ -1597,10 +1594,7 @@ pub trait DeviceV1_0 {
             data.as_mut_ptr() as _,
         );
         data.set_len(data_size);
-        match err_code {
-            vk::Result::SUCCESS => Ok(data),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(data)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMapMemory.html>"]
@@ -1826,10 +1820,7 @@ pub trait DeviceV1_0 {
             buffers.as_mut_ptr(),
         );
         buffers.set_len(create_info.command_buffer_count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(buffers),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(buffers)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateCommandPool.html>"]

ash/src/entry.rs

@@ -57,21 +57,15 @@ pub trait EntryV1_0 {
     fn enumerate_instance_layer_properties(&self) -> VkResult<Vec<vk::LayerProperties>> {
         unsafe {
             let mut num = 0;
-            let err_code = self
-                .fp_v1_0()
-                .enumerate_instance_layer_properties(&mut num, ptr::null_mut());
-            if err_code != vk::Result::SUCCESS {
-                return Err(err_code);
-            }
+            self.fp_v1_0()
+                .enumerate_instance_layer_properties(&mut num, ptr::null_mut())
+                .result()?;
             let mut v = Vec::with_capacity(num as usize);
             let err_code = self
                 .fp_v1_0()
                 .enumerate_instance_layer_properties(&mut num, v.as_mut_ptr());
             v.set_len(num as usize);
-            match err_code {
-                vk::Result::SUCCESS => Ok(v),
-                _ => Err(err_code),
-            }
+            err_code.result_with_success(v)
         }
     }
 
@@ -89,10 +83,7 @@ pub trait EntryV1_0 {
                 data.as_mut_ptr(),
             );
             data.set_len(num as usize);
-            match err_code {
-                vk::Result::SUCCESS => Ok(data),
-                _ => Err(err_code),
-            }
+            err_code.result_with_success(data)
         }
     }
 
@@ -120,14 +111,14 @@ impl<L> EntryV1_0 for EntryCustom<L> {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> Result<Self::Instance, InstanceError> {
         let mut instance: vk::Instance = mem::zeroed();
-        let err_code = self.fp_v1_0().create_instance(
-            create_info,
-            allocation_callbacks.as_raw_ptr(),
-            &mut instance,
-        );
-        if err_code != vk::Result::SUCCESS {
-            return Err(InstanceError::VkError(err_code));
-        }
+        self.fp_v1_0()
+            .create_instance(
+                create_info,
+                allocation_callbacks.as_raw_ptr(),
+                &mut instance,
+            )
+            .result()
+            .map_err(InstanceError::VkError)?;
         Ok(Instance::load(&self.static_fn, instance))
     }
     fn fp_v1_0(&self) -> &vk::EntryFnV1_0 {

ash/src/extensions/ext/tooling_info.rs

@@ -33,21 +33,15 @@ impl ToolingInfo {
         physical_device: vk::PhysicalDevice,
     ) -> VkResult<Vec<vk::PhysicalDeviceToolPropertiesEXT>> {
         let mut count = 0;
-        let err_code = self
-            .tooling_info_fn
-            .get_physical_device_tool_properties_ext(physical_device, &mut count, ptr::null_mut());
-        if err_code != vk::Result::SUCCESS {
-            return Err(err_code);
-        }
+        self.tooling_info_fn
+            .get_physical_device_tool_properties_ext(physical_device, &mut count, ptr::null_mut())
+            .result()?;
         let mut v = Vec::with_capacity(count as usize);
         let err_code = self
             .tooling_info_fn
             .get_physical_device_tool_properties_ext(physical_device, &mut count, v.as_mut_ptr());
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     pub fn fp(&self) -> &vk::ExtToolingInfoFn {

ash/src/extensions/khr/display.rs

@@ -47,10 +47,7 @@ impl Display {
             v.as_mut_ptr(),
         );
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html>"]
@@ -78,10 +75,7 @@ impl Display {
                 v.as_mut_ptr(),
             );
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html>"]
@@ -107,10 +101,7 @@ impl Display {
             v.as_mut_ptr(),
         );
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayModePropertiesKHR.html>"]
@@ -131,10 +122,7 @@ impl Display {
             v.as_mut_ptr(),
         );
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDisplayModeKHR.html>"]

ash/src/extensions/khr/display_swapchain.rs

@@ -42,10 +42,7 @@ impl DisplaySwapchain {
             swapchains.as_mut_ptr(),
         );
         swapchains.set_len(create_infos.len());
-        match err_code {
-            vk::Result::SUCCESS => Ok(swapchains),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(swapchains)
     }
 
     pub fn fp(&self) -> &vk::KhrDisplaySwapchainFn {

ash/src/extensions/khr/external_memory_fd.rs

@@ -28,13 +28,10 @@ impl ExternalMemoryFd {
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryFdKHR.html>"]
     pub unsafe fn get_memory_fd(&self, create_info: &vk::MemoryGetFdInfoKHR) -> VkResult<i32> {
         let mut fd = -1;
-        let err_code =
-            self.external_memory_fd_fn
-                .get_memory_fd_khr(self.handle, create_info, &mut fd);
-        match err_code {
-            vk::Result::SUCCESS => Ok(fd),
-            _ => Err(err_code),
-        }
+
+        self.external_memory_fd_fn
+            .get_memory_fd_khr(self.handle, create_info, &mut fd)
+            .result_with_success(fd)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryFdPropertiesKHR.html>"]

ash/src/extensions/khr/pipeline_executable_properties.rs

@@ -51,18 +51,14 @@ impl PipelineExecutableProperties {
             return Err(err_code);
         }
         let mut v: Vec<_> = vec![Default::default(); count as usize];
-        let err_code = self
-            .pipeline_executable_properties_fn
+        self.pipeline_executable_properties_fn
             .get_pipeline_executable_internal_representations_khr(
                 device,
                 executable_info,
                 &mut count,
                 v.as_mut_ptr(),
-            );
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+            )
+            .result_with_success(v)
     }
 
     #[doc = "https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutablePropertiesKHR.html"]
@@ -84,18 +80,14 @@ impl PipelineExecutableProperties {
             return Err(err_code);
         }
         let mut v: Vec<_> = vec![Default::default(); count as usize];
-        let err_code = self
-            .pipeline_executable_properties_fn
+        self.pipeline_executable_properties_fn
             .get_pipeline_executable_properties_khr(
                 device,
                 pipeline_info,
                 &mut count,
                 v.as_mut_ptr(),
-            );
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+            )
+            .result_with_success(v)
     }
 
     #[doc = "https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutableStatisticsKHR.html"]
@@ -117,18 +109,14 @@ impl PipelineExecutableProperties {
             return Err(err_code);
         }
         let mut v: Vec<_> = vec![Default::default(); count as usize];
-        let err_code = self
-            .pipeline_executable_properties_fn
+        self.pipeline_executable_properties_fn
             .get_pipeline_executable_statistics_khr(
                 device,
                 executable_info,
                 &mut count,
                 v.as_mut_ptr(),
-            );
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+            )
+            .result_with_success(v)
     }
 
     pub fn fp(&self) -> &vk::KhrPipelineExecutablePropertiesFn {

ash/src/extensions/khr/ray_tracing.rs

@@ -283,21 +283,16 @@ impl RayTracing {
     ) -> VkResult<Vec<u8>> {
         let mut data: Vec<u8> = Vec::with_capacity(data_size);
 
-        let err_code = self
-            .ray_tracing_fn
+        self.ray_tracing_fn
             .get_ray_tracing_capture_replay_shader_group_handles_khr(
                 device,
                 pipeline,
                 first_group,
                 group_count,
                 data_size,
                 data.as_mut_ptr() as *mut _,
-            );
-
-        match err_code {
-            vk::Result::SUCCESS => Ok(data),
-            _ => Err(err_code),
-        }
+            )
+            .result_with_success(data)
     }
 
     pub unsafe fn cmd_trace_rays_indirect(

ash/src/extensions/khr/surface.rs

@@ -48,17 +48,14 @@ impl Surface {
         surface: vk::SurfaceKHR,
     ) -> VkResult<Vec<vk::PresentModeKHR>> {
         let mut count = 0;
-        let err_code = self
-            .surface_fn
+        self.surface_fn
             .get_physical_device_surface_present_modes_khr(
                 physical_device,
                 surface,
                 &mut count,
                 ptr::null_mut(),
-            );
-        if err_code != vk::Result::SUCCESS {
-            return Err(err_code);
-        }
+            )
+            .result()?;
         let mut v = Vec::with_capacity(count as usize);
         let err_code = self
             .surface_fn
@@ -69,10 +66,7 @@ impl Surface {
                 v.as_mut_ptr(),
             );
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html>"]
@@ -82,17 +76,13 @@ impl Surface {
         surface: vk::SurfaceKHR,
     ) -> VkResult<vk::SurfaceCapabilitiesKHR> {
         let mut surface_capabilities = mem::zeroed();
-        let err_code = self
-            .surface_fn
+        self.surface_fn
             .get_physical_device_surface_capabilities_khr(
                 physical_device,
                 surface,
                 &mut surface_capabilities,
-            );
-        match err_code {
-            vk::Result::SUCCESS => Ok(surface_capabilities),
-            _ => Err(err_code),
-        }
+            )
+            .result_with_success(surface_capabilities)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html>"]
@@ -118,10 +108,7 @@ impl Surface {
             v.as_mut_ptr(),
         );
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySurfaceKHR.html>"]

ash/src/extensions/khr/swapchain.rs

@@ -116,10 +116,7 @@ impl Swapchain {
             v.as_mut_ptr(),
         );
         v.set_len(count as usize);
-        match err_code {
-            vk::Result::SUCCESS => Ok(v),
-            _ => Err(err_code),
-        }
+        err_code.result_with_success(v)
     }
 
     pub fn fp(&self) -> &vk::KhrSwapchainFn {

ash/src/extensions/khr/timeline_semaphore.rs

@@ -34,14 +34,9 @@ impl TimelineSemaphore {
         semaphore: vk::Semaphore,
     ) -> VkResult<u64> {
         let mut value = 0;
-        let err_code = self
-            .timeline_semaphore_fn
-            .get_semaphore_counter_value_khr(device, semaphore, &mut value);
-
-        match err_code {
-            vk::Result::SUCCESS => Ok(value),
-            _ => Err(err_code),
-        }
+        self.timeline_semaphore_fn
+            .get_semaphore_counter_value_khr(device, semaphore, &mut value)
+            .result_with_success(value)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitSemaphores.html>"]