allocator::win32::CoTaskMem: fix ZST reallocs by always requesting at least one byte

relates to #32

Author: MaulingMonkey

src/allocator/win32/cotaskmem.rs

@@ -10,14 +10,17 @@ use core::ptr::NonNull;
 
 /// [`CoTaskMemAlloc`] / [`CoTaskMemRealloc`] / [`CoTaskMemFree`]
 ///
+/// Uses the default COM / "OLE task memory" allocator provided by [`CoGetMalloc`], which in turn simply uses [`Heap*`](super::Heap) functions under the hood.
+/// Consider using [`Heap`](super::Heap) directly instead, unless you're specifically doing COM / have documentation mandating a specific (de)allocator for interop purpouses.
+///
 /// | Rust                              | C                     |
 /// | ----------------------------------| ----------------------|
-/// | [`thin::Alloc::alloc_uninit`]     | [`CoTaskMemAlloc`]
-/// | [`thin::Realloc::realloc_uninit`] | [`CoTaskMemRealloc`]
+/// | [`thin::Alloc::alloc_uninit`]     | [`CoTaskMemAlloc`] <sup>\[1\]</sup>
+/// | [`thin::Realloc::realloc_uninit`] | [`CoTaskMemRealloc`] <sup>\[2\]</sup>
 /// | [`thin::Free::free`]              | [`CoTaskMemFree`]
 ///
-/// Uses the default COM / "OLE task memory" allocator provided by [`CoGetMalloc`], which in turn simply uses [`Heap*`](super::Heap) functions under the hood.
-/// Consider using [`Heap`](super::Heap) directly instead, unless you're specifically doing COM / have documentation mandating a specific (de)allocator for interop purpouses.
+/// 1. `size` / `layout` of 0 bytes will allocate successfully
+/// 2. `new_size` / `new_layout` will be rounded up to at least 1 byte, otherwise [`CoTaskMemRealloc`] would free!
 ///
 /// ## References
 /// *   [`IMalloc`](super::IMalloc) (stateful equivalent)
@@ -35,6 +38,11 @@ impl Meta for CoTaskMem {
     const MIN_ALIGN : Alignment = super::MEMORY_ALLOCATION_ALIGNMENT; // Verified through testing
     const MAX_ALIGN : Alignment = super::MEMORY_ALLOCATION_ALIGNMENT; // Verified through testing
     const MAX_SIZE  : usize     = usize::MAX;
+
+    /// -   `CoTaskMemAlloc(0)` allocates successfully.
+    /// -   `CoTaskMemRealloc(ptr, 0)` **frees**.
+    ///     Note that [`thin::Realloc`] and [`fat::Realloc`] resolve this by always requesting at least 1 byte.
+    ///
     const ZST_SUPPORTED : bool  = true;
 }
 
@@ -90,7 +98,7 @@ unsafe impl thin::Realloc for CoTaskMem {
 
     unsafe fn realloc_uninit(&self, ptr: AllocNN, new_size: usize) -> Result<AllocNN, Self::Error> {
         // SAFETY: ✔️ `ptr` belongs to `self` per [`thin::Realloc::realloc_uninit`]'s documented safety preconditions, and thus was allocated with CoTaskMem{Alloc,Realloc}
-        let alloc = unsafe { CoTaskMemRealloc(ptr.as_ptr().cast(), new_size) };
+        let alloc = unsafe { CoTaskMemRealloc(ptr.as_ptr().cast(), new_size.max(1)) };
         NonNull::new(alloc.cast()).ok_or(())
     }
 
@@ -133,11 +141,15 @@ unsafe impl thin::Free for CoTaskMem {
 #[test] fn thin_nullable()          { thin::test::nullable(CoTaskMem) }
 //#[test] fn thin_size()              { ...no CoTaskMemSizeOf... }
 #[test] fn thin_uninit()            { unsafe { thin::test::uninit_alloc_unsound(CoTaskMem) } }
+#[test] fn thin_uninit_realloc()    { thin::test::uninit_realloc(CoTaskMem) }
 #[test] fn thin_zeroed()            { thin::test::zeroed_alloc(CoTaskMem) }
+#[test] fn thin_zeroed_realloc()    { thin::test::zeroed_realloc(CoTaskMem) }
 #[test] fn thin_zst_support()       { thin::test::zst_supported_accurate(CoTaskMem) }
 
 #[test] fn fat_alignment()          { fat::test::alignment(CoTaskMem) }
 #[test] fn fat_edge_case_sizes()    { fat::test::edge_case_sizes(CoTaskMem) }
 #[test] fn fat_uninit()             { unsafe { fat::test::uninit_alloc_unsound(CoTaskMem) } }
+#[test] fn fat_uninit_realloc()     { fat::test::uninit_realloc(CoTaskMem) }
 #[test] fn fat_zeroed()             { fat::test::zeroed_alloc(CoTaskMem) }
+#[test] fn fat_zeroed_realloc()     { fat::test::zeroed_realloc(CoTaskMem) }
 #[test] fn fat_zst_support()        { fat::test::zst_supported_accurate(CoTaskMem) }