From 60b47dba2937366d168694832df4134a498d509a Mon Sep 17 00:00:00 2001
From: Matt Corallo <git@bluematt.me>
Date: Wed, 9 Feb 2022 21:16:31 +0000
Subject: [PATCH] Convert slices containing non-primitives that are clonable

---
 c-bindings-gen/src/types.rs | 43 +++++++++++++++++++++++++++++--------
 1 file changed, 34 insertions(+), 9 deletions(-)

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 34b7a60..007441e 100644
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -1898,8 +1898,11 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 				// This may result in some outputs not compiling.
 				if let syn::Type::Path(p) = &*s.elem {
 					let resolved = self.resolve_path(&p.path, generics);
-					assert!(self.is_primitive(&resolved));
-					write!(w, "{}", path_lookup("[u8]", is_ref, ptr_for_ref).unwrap()).unwrap();
+					if self.is_primitive(&resolved) {
+						write!(w, "{}", path_lookup("[u8]", is_ref, ptr_for_ref).unwrap()).unwrap();
+					} else {
+						write!(w, "{}", sliceconv(true, None)).unwrap();
+					}
 				} else if let syn::Type::Reference(r) = &*s.elem {
 					if let syn::Type::Path(p) = &*r.elem {
 						write!(w, "{}", sliceconv(self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)), None)).unwrap();
@@ -2246,12 +2249,24 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 			syn::Type::Slice(s) => {
 				if let syn::Type::Path(p) = &*s.elem {
 					let resolved = self.resolve_path(&p.path, generics);
-					assert!(self.is_primitive(&resolved));
-					let slice_path = format!("[{}]", resolved);
-					if let Some((prefix, suffix)) = path_lookup(&slice_path, true) {
-						write!(w, "let mut local_{} = {}{}{};", ident, prefix, var, suffix).unwrap();
-						true
-					} else { false }
+					if self.is_primitive(&resolved) {
+						let slice_path = format!("[{}]", resolved);
+						if let Some((prefix, suffix)) = path_lookup(&slice_path, true) {
+							write!(w, "let mut local_{} = {}{}{};", ident, prefix, var, suffix).unwrap();
+							true
+						} else { false }
+					} else {
+						let tyref = [&*s.elem];
+						if to_c {
+							// If we're converting from a slice to a Vec, assume we can clone the
+							// elements and clone them into a new Vec first. Next we'll walk the
+							// new Vec here and convert them to C types.
+							write!(w, "let mut local_{}_clone = Vec::new(); local_{}_clone.extend_from_slice({}); let mut {} = local_{}_clone; ", ident, ident, ident, ident, ident).unwrap();
+						}
+						is_ref = false;
+						convert_container!("Vec", 1, || tyref.iter().map(|t| generics.resolve_type(*t)));
+						unimplemented!("convert_container should return true as container_lookup should succeed for slices");
+					}
 				} else if let syn::Type::Reference(ty) = &*s.elem {
 					let tyref = if from_ownable_ref || !to_c { [&*ty.elem] } else { [&*s.elem] };
 					is_ref = true;
@@ -2721,7 +2736,17 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
 					if self.is_primitive(&resolved) {
 						write!(w, "{}::{}slice", Self::container_templ_path(), resolved).unwrap();
 						true
-					} else { false }
+					} else {
+						let mut inner_c_ty = Vec::new();
+						assert!(self.write_c_path_intern(&mut inner_c_ty, &p.path, generics, true, false, ptr_for_ref, with_ref_lifetime));
+						if self.is_clonable(&String::from_utf8(inner_c_ty).unwrap()) {
+							if let Some(id) = p.path.get_ident() {
+								let mangled_container = format!("CVec_{}Z", id);
+								write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap();
+								self.check_create_container(mangled_container, "Vec", vec![&*s.elem], generics, false)
+							} else { false }
+						} else { false }
+					}
 				} else if let syn::Type::Reference(r) = &*s.elem {
 					if let syn::Type::Path(p) = &*r.elem {
 						// Slices with "real types" inside are mapped as the equivalent non-ref Vec
-- 
2.39.5