Add conversion logic for boxed_vec, simplify vec creation code

lib/c-api/src/wasm_c_api/macros.rs

@@ -8,16 +8,6 @@ macro_rules! wasm_declare_vec_inner {
                 // TODO: actually implement this
                 [<wasm_ $name _vec_new_uninitialized>](out, 0);
             }
-
-            #[no_mangle]
-            pub unsafe extern "C" fn [<wasm_ $name _vec_delete>](ptr: *mut [<wasm_ $name _vec_t>]) {
-                let vec = &mut *ptr;
-                if !vec.data.is_null() {
-                    Vec::from_raw_parts(vec.data, vec.size, vec.size);
-                    vec.data = ::std::ptr::null_mut();
-                    vec.size = 0;
-                }
-            }
         }
     }
 }
@@ -96,6 +86,17 @@ macro_rules! wasm_declare_vec {
                 (*out).size = length;
                 ::std::mem::forget(bytes);
             }
+
+
+            #[no_mangle]
+            pub unsafe extern "C" fn [<wasm_ $name _vec_delete>](ptr: *mut [<wasm_ $name _vec_t>]) {
+                let vec = &mut *ptr;
+                if !vec.data.is_null() {
+                    Vec::from_raw_parts(vec.data, vec.size, vec.size);
+                    vec.data = ::std::ptr::null_mut();
+                    vec.size = 0;
+                }
+            }
         }
 
         wasm_declare_vec_inner!($name);
@@ -113,6 +114,21 @@ macro_rules! wasm_declare_boxed_vec {
                 pub data: *mut *mut [<wasm_ $name _t>],
             }
 
+            impl<'a> From<Vec<Box<[<wasm_ $name _t>]>>> for [<wasm_ $name _vec_t>] {
+                fn from(other: Vec<Box<[<wasm_ $name _t>]>>) -> Self {
+                    let boxed_slice: Box<[Box<[<wasm_ $name _t>]>]> = other.into_boxed_slice();
+                    let mut boxed_slice: Box<[*mut [<wasm_ $name _t>]]> = unsafe { ::std::mem::transmute(boxed_slice) };
+                    let size = boxed_slice.len();
+                    let data = boxed_slice.as_mut_ptr();
+
+                    ::std::mem::forget(boxed_slice);
+                    Self {
+                        size,
+                        data,
+                    }
+                }
+            }
+
             // TODO: do this properly
             impl [<wasm_ $name _vec_t>] {
                 pub unsafe fn into_slice(&self) -> Option<&[*mut [<wasm_ $name _t>]]>{
@@ -146,6 +162,17 @@ macro_rules! wasm_declare_boxed_vec {
                 (*out).size = length;
                 ::std::mem::forget(bytes);
             }
+
+            #[no_mangle]
+            pub unsafe extern "C" fn [<wasm_ $name _vec_delete>](ptr: *mut [<wasm_ $name _vec_t>]) {
+                let vec = &mut *ptr;
+                if !vec.data.is_null() {
+                    let data: Vec<*mut [<wasm_ $name _t>]> = Vec::from_raw_parts(vec.data, vec.size, vec.size);
+                    let data: Vec<Box<[<wasm_ $name _t>]>> = ::std::mem::transmute(data);
+                    vec.data = ::std::ptr::null_mut();
+                    vec.size = 0;
+                }
+            }
         }
 
         wasm_declare_vec_inner!($name);

lib/c-api/src/wasm_c_api/module.rs

@@ -38,18 +38,14 @@ pub unsafe extern "C" fn wasm_module_exports(
     module: &wasm_module_t,
     out: &mut wasm_exporttype_vec_t,
 ) {
-    let mut exports = module
+    let exports = module
         .inner
         .exports()
         .map(Into::into)
         .map(Box::new)
-        .map(Box::into_raw)
+        .collect::<Vec<Box<wasm_exporttype_t>>>();
-        .collect::<Vec<*mut wasm_exporttype_t>>();
 
-    debug_assert_eq!(exports.len(), exports.capacity());
+    *out = exports.into();
-    out.size = exports.len();
-    out.data = exports.as_mut_ptr();
-    mem::forget(exports);
 }
 
 #[no_mangle]
@@ -57,18 +53,14 @@ pub unsafe extern "C" fn wasm_module_imports(
     module: &wasm_module_t,
     out: &mut wasm_importtype_vec_t,
 ) {
-    let mut imports = module
+    let imports = module
         .inner
         .imports()
         .map(Into::into)
         .map(Box::new)
-        .map(Box::into_raw)
+        .collect::<Vec<Box<wasm_importtype_t>>>();
-        .collect::<Vec<*mut wasm_importtype_t>>();
 
-    debug_assert_eq!(imports.len(), imports.capacity());
+    *out = imports.into();
-    out.size = imports.len();
-    out.data = imports.as_mut_ptr();
-    mem::forget(imports);
 }
 
 #[no_mangle]
@@ -102,16 +94,8 @@ pub unsafe extern "C" fn wasm_module_serialize(
     out_ptr: &mut wasm_byte_vec_t,
 ) {
     let mut byte_vec = match module.inner.serialize() {
-        Ok(mut byte_vec) => {
+        Ok(byte_vec) => byte_vec,
-            byte_vec.shrink_to_fit();
-            byte_vec
-        }
         Err(_) => return,
     };
-    // ensure we won't leak memory
+    *out_ptr = byte_vec.into();
-    // TODO: use `Vec::into_raw_parts` when it becomes stable
-    debug_assert_eq!(byte_vec.capacity(), byte_vec.len());
-    out_ptr.size = byte_vec.len();
-    out_ptr.data = byte_vec.as_mut_ptr();
-    mem::forget(byte_vec);
 }