Avoid double allocation when passing strings via IntoParam

crates/libs/windows/src/core/heap.rs

@@ -32,20 +32,42 @@ pub unsafe fn heap_free(ptr: RawPtr) {
     }
 }
 
-/// Copy a slice of `T` into a freshly allocated buffer with an additional default `T` at the end.
+/// Copy an iterator of `T` into a freshly allocated buffer with an additional default `T` at the end.
 ///
-/// Returns a pointer to the beginning of the buffer
+/// Returns a pointer to the beginning of the buffer. This pointer must be freed when done using `heap_free`.
 ///
 /// # Panics
 ///
-/// This function panics if the heap allocation fails or if the pointer returned from
-/// the heap allocation is not properly aligned to `T`.
-pub fn heap_string<T: Copy + Default + Sized>(slice: &[T]) -> *const T {
-    unsafe {
-        let buffer = heap_alloc((slice.len() + 1) * std::mem::size_of::<T>()).expect("could not allocate string") as *mut T;
-        assert!(buffer.align_offset(std::mem::align_of::<T>()) == 0, "heap allocated buffer is not properly aligned");
-        buffer.copy_from_nonoverlapping(slice.as_ptr(), slice.len());
-        buffer.add(slice.len()).write(T::default());
-        buffer
+/// This function panics if the heap allocation fails, the alignment requirements of 'T' surpass
+/// 8 (HeapAlloc's alignment) or if len is less than the number of items in the iterator.
+pub fn string_from_iter<I, T>(iter: I, len: usize) -> *const T
+where
+    I: Iterator<Item = T>,
+    T: Copy + Default,
+{
+    // alignment of memory returned by HeapAlloc is at least 8
+    // Source: https://docs.microsoft.com/en-us/windows/win32/api/heapapi/nf-heapapi-heapalloc
+    // Ensure that T has sufficient alignment requirements
+    assert!(std::mem::align_of::<T>() <= 8, "T alignment surpasses HeapAlloc alignment");
+
+    let len = len + 1;
+    let ptr = heap_alloc(len * std::mem::size_of::<T>()).expect("could not allocate string") as *mut T;
+    let mut encoder = iter.chain(core::iter::once(T::default()));
+
+    for i in 0..len {
+        // SAFETY: ptr points to an allocation object of size `len`, indices accessed are always lower than `len`
+        unsafe {
+            core::ptr::write(
+                ptr.add(i),
+                match encoder.next() {
+                    Some(encoded) => encoded,
+                    None => break,
+                },
+            );
+        }
     }
+
+    assert!(encoder.next().is_none(), "encoder returned more characters than expected");
+
+    ptr
 }

crates/libs/windows/src/core/pcstr.rs

@@ -45,7 +45,7 @@ unsafe impl Abi for PCSTR {
 #[cfg(feature = "alloc")]
 impl<'a> IntoParam<'a, PCSTR> for &str {
     fn into_param(self) -> Param<'a, PCSTR> {
-        Param::Boxed(PCSTR(heap_string(self.as_bytes())))
+        Param::Boxed(PCSTR(string_from_iter(self.as_bytes().iter().copied(), self.len())))
     }
 }
 #[cfg(feature = "alloc")]

crates/libs/windows/src/core/pcwstr.rs

@@ -45,7 +45,7 @@ unsafe impl Abi for PCWSTR {
 #[cfg(feature = "alloc")]
 impl<'a> IntoParam<'a, PCWSTR> for &str {
     fn into_param(self) -> Param<'a, PCWSTR> {
-        Param::Boxed(PCWSTR(heap_string(&self.encode_utf16().collect::<alloc::vec::Vec<u16>>())))
+        Param::Boxed(PCWSTR(string_from_iter(self.encode_utf16(), self.len())))
     }
 }
 #[cfg(feature = "alloc")]
@@ -58,7 +58,7 @@ impl<'a> IntoParam<'a, PCWSTR> for alloc::string::String {
 impl<'a> IntoParam<'a, PCWSTR> for &::std::ffi::OsStr {
     fn into_param(self) -> Param<'a, PCWSTR> {
         use ::std::os::windows::ffi::OsStrExt;
-        Param::Boxed(PCWSTR(heap_string(&self.encode_wide().collect::<alloc::vec::Vec<u16>>())))
+        Param::Boxed(PCWSTR(string_from_iter(self.encode_wide(), self.len())))
     }
 }
 #[cfg(feature = "alloc")]