Preliminary cleanup pass

ash/src/entry.rs

@@ -58,40 +58,32 @@ pub trait EntryV1_0 {
         unsafe {
             let mut num = 0;
             self.fp_v1_0()
-                .enumerate_instance_layer_properties(&mut num, ptr::null_mut());
-
+                .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)
         }
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html>"]
     fn enumerate_instance_extension_properties(&self) -> VkResult<Vec<vk::ExtensionProperties>> {
         unsafe {
             let mut num = 0;
-            self.fp_v1_0().enumerate_instance_extension_properties(
-                ptr::null(),
-                &mut num,
-                ptr::null_mut(),
-            );
+            self.fp_v1_0()
+                .enumerate_instance_extension_properties(ptr::null(), &mut num, ptr::null_mut())
+                .result()?;
             let mut data = Vec::with_capacity(num as usize);
             let err_code = self.fp_v1_0().enumerate_instance_extension_properties(
                 ptr::null(),
                 &mut num,
                 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)
         }
     }
 
@@ -119,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 {
@@ -146,11 +138,9 @@ pub trait EntryV1_1: EntryV1_0 {
     fn enumerate_instance_version(&self) -> VkResult<u32> {
         unsafe {
             let mut api_version = 0;
-            let err_code = self.fp_v1_1().enumerate_instance_version(&mut api_version);
-            match err_code {
-                vk::Result::SUCCESS => Ok(api_version),
-                _ => Err(err_code),
-            }
+            self.fp_v1_1()
+                .enumerate_instance_version(&mut api_version)
+                .result_with_success(api_version)
         }
     }
 }
@@ -228,11 +218,8 @@ impl<L> EntryCustom<L> {
                 )
             };
             if let Some(enumerate_instance_version) = enumerate_instance_version {
-                let err_code = (enumerate_instance_version)(&mut api_version);
-                match err_code {
-                    vk::Result::SUCCESS => Ok(Some(api_version)),
-                    _ => Err(err_code),
-                }
+                (enumerate_instance_version)(&mut api_version)
+                    .result_with_success(Some(api_version))
             } else {
                 Ok(None)
             }

ash/src/extensions/ext/debug_marker.rs

@@ -28,13 +28,9 @@ impl DebugMarker {
         device: vk::Device,
         name_info: &vk::DebugMarkerObjectNameInfoEXT,
     ) -> VkResult<()> {
-        let err_code = self
-            .debug_marker_fn
-            .debug_marker_set_object_name_ext(device, name_info);
-        match err_code {
-            vk::Result::SUCCESS => Ok(()),
-            _ => Err(err_code),
-        }
+        self.debug_marker_fn
+            .debug_marker_set_object_name_ext(device, name_info)
+            .into()
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDebugMarkerBeginEXT.html>"]

ash/src/extensions/ext/debug_report.rs

@@ -47,16 +47,14 @@ impl DebugReport {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DebugReportCallbackEXT> {
         let mut debug_cb = mem::zeroed();
-        let err_code = self.debug_report_fn.create_debug_report_callback_ext(
-            self.handle,
-            create_info,
-            allocation_callbacks.as_raw_ptr(),
-            &mut debug_cb,
-        );
-        match err_code {
-            vk::Result::SUCCESS => Ok(debug_cb),
-            _ => Err(err_code),
-        }
+        self.debug_report_fn
+            .create_debug_report_callback_ext(
+                self.handle,
+                create_info,
+                allocation_callbacks.as_raw_ptr(),
+                &mut debug_cb,
+            )
+            .result_with_success(debug_cb)
     }
 
     pub fn fp(&self) -> &vk::ExtDebugReportFn {

ash/src/extensions/ext/debug_utils.rs

@@ -32,13 +32,9 @@ impl DebugUtils {
         device: vk::Device,
         name_info: &vk::DebugUtilsObjectNameInfoEXT,
     ) -> VkResult<()> {
-        let err_code = self
-            .debug_utils_fn
-            .set_debug_utils_object_name_ext(device, name_info);
-        match err_code {
-            vk::Result::SUCCESS => Ok(()),
-            _ => Err(err_code),
-        }
+        self.debug_utils_fn
+            .set_debug_utils_object_name_ext(device, name_info)
+            .into()
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetDebugUtilsObjectTagEXT.html>"]
@@ -47,13 +43,9 @@ impl DebugUtils {
         device: vk::Device,
         tag_info: &vk::DebugUtilsObjectTagInfoEXT,
     ) -> VkResult<()> {
-        let err_code = self
-            .debug_utils_fn
-            .set_debug_utils_object_tag_ext(device, tag_info);
-        match err_code {
-            vk::Result::SUCCESS => Ok(()),
-            _ => Err(err_code),
-        }
+        self.debug_utils_fn
+            .set_debug_utils_object_tag_ext(device, tag_info)
+            .into()
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginDebugUtilsLabelEXT.html>"]
@@ -114,16 +106,14 @@ impl DebugUtils {
         allocator: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DebugUtilsMessengerEXT> {
         let mut messenger = mem::zeroed();
-        let err_code = self.debug_utils_fn.create_debug_utils_messenger_ext(
-            self.handle,
-            create_info,
-            allocator.as_raw_ptr(),
-            &mut messenger,
-        );
-        match err_code {
-            vk::Result::SUCCESS => Ok(messenger),
-            _ => Err(err_code),
-        }
+        self.debug_utils_fn
+            .create_debug_utils_messenger_ext(
+                self.handle,
+                create_info,
+                allocator.as_raw_ptr(),
+                &mut messenger,
+            )
+            .result_with_success(messenger)
     }
 
     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDebugUtilsMessengerEXT.html>"]

ash/src/extensions/ext/metal_surface.rs

@@ -34,16 +34,14 @@ impl MetalSurface {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        let err_code = self.metal_surface_fn.create_metal_surface_ext(
-            self.handle,
-            create_info,
-            allocation_callbacks.as_raw_ptr(),
-            &mut surface,
-        );
-        match err_code {
-            vk::Result::SUCCESS => Ok(surface),
-            _ => Err(err_code),
-        }
+        self.metal_surface_fn
+            .create_metal_surface_ext(
+                self.handle,
+                create_info,
+                allocation_callbacks.as_raw_ptr(),
+                &mut surface,
+            )
+            .result_with_success(surface)
     }
 
     pub fn fp(&self) -> &vk::ExtMetalSurfaceFn {

ash/src/extensions/ext/tooling_info.rs

@@ -34,16 +34,14 @@ impl ToolingInfo {
     ) -> VkResult<Vec<vk::PhysicalDeviceToolPropertiesEXT>> {
         let mut count = 0;
         self.tooling_info_fn
-            .get_physical_device_tool_properties_ext(physical_device, &mut count, ptr::null_mut());
+            .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/android_surface.rs

@@ -34,16 +34,14 @@ impl AndroidSurface {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        let err_code = self.android_surface_fn.create_android_surface_khr(
-            self.handle,
-            create_info,
-            allocation_callbacks.as_raw_ptr(),
-            &mut surface,
-        );
-        match err_code {
-            vk::Result::SUCCESS => Ok(surface),
-            _ => Err(err_code),
-        }
+        self.android_surface_fn
+            .create_android_surface_khr(
+                self.handle,
+                create_info,
+                allocation_callbacks.as_raw_ptr(),
+                &mut surface,
+            )
+            .result_with_success(surface)
     }
 
     pub fn fp(&self) -> &vk::KhrAndroidSurfaceFn {