Switch from mem::zeroed to MaybeUninit<T>

[gwihlidal]

Newer rust compiler now warns about usage of mem::zeroed.

warning: the type `ash::Instance` does not permit zero-initialization
   --> src/lib.rs:263:32
    |
263 |             instance: unsafe { mem::zeroed() },
    |                                ^^^^^^^^^^^^^
    |                                |
    |                                this code causes undefined behavior when executed
    |                                help: use `MaybeUninit<T>` instead
    |
note: Function pointers must be non-null (in this struct field)

This warning is currently silenced in lib.rs:

#![allow(invalid_value)]

It would be good to remove the allow pragma and switch to MaybeUninit.

[aloucks]

I don't think MaybeUnit will help in the impl for Default. The Device and Instance structs contain function pointers that must be filled with valid values or it's UB.

I think there's a couple of options:

1. Make the device and instance fields Option<Device> and Option<Instance> and return an error in in Allocator::new if either are None.
2. Remove the Default implementation for AllocatorCreateInfo.
3. Create dummy values for device and instance that are technically valid, but will panic if you attempt to use them.

I experimented with #3 and all unit tests are passing. I can open a PR if you want to go this route.

/// Construct `AllocatorCreateInfo` with default values
///
/// Note that the default `device` and `instance` fields are filled with dummy
/// implementations that will panic if used. These fields must be overwritten.
impl Default for AllocatorCreateInfo {
    fn default() -> Self {
        extern "C" fn get_device_proc_addr(
            _: ash::vk::Instance,
            _: *const std::os::raw::c_char,
        ) -> *const std::os::raw::c_void {
            std::ptr::null()
        }
        extern "C" fn get_instance_proc_addr(
            _: ash::vk::Instance,
            name: *const std::os::raw::c_char,
        ) -> *const std::os::raw::c_void {
            get_device_proc_addr as *const _
        }
        let static_fn = ash::vk::StaticFn::load(|_| get_instance_proc_addr as *const _);
        let instance = unsafe { ash::Instance::load(&static_fn, ash::vk::Instance::null()) };
        let device = unsafe { ash::Device::load(&instance.fp_v1_0(), ash::vk::Device::null()) };
        AllocatorCreateInfo {
            physical_device: ash::vk::PhysicalDevice::null(),
            device,
            instance,
            flags: AllocatorCreateFlags::NONE,
            preferred_large_heap_block_size: 0,
            frame_in_use_count: 0,
            heap_size_limits: None,
        }
    }
}

[gwihlidal]

Sure, that's probably a fine approach to start with for now.