Support custom Rust types for list

Any type that implements `From<Vec<T>>`, `Into<Vec<T>>` and
`Deref<Target = Vec<T>>` can be used for a WIT type `list<T>` via the
`with` option.

Author: azdle

crates/rust/src/bindgen.rs

@@ -674,7 +674,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     self.push_str(&format!("let {} = {};\n", val, operands[0]));
                 } else {
                     let op0 = operands.pop().unwrap();
-                    self.push_str(&format!("let {} = ({}).into_boxed_slice();\n", val, op0));
+                    self.push_str(&format!(
+                        "let {} = <_ as Into<Vec<_>>>::into({}).into_boxed_slice();\n",
+                        val, op0
+                    ));
                 }
                 self.push_str(&format!("let {} = {}.as_ptr().cast::<u8>();\n", ptr, val));
                 self.push_str(&format!("let {} = {}.len();\n", len, val));
@@ -691,7 +694,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 self.push_str(&format!("let {} = {};\n", len, operands[1]));
                 let vec = self.r#gen.path_to_vec();
                 let result = format!(
-                    "{vec}::from_raw_parts({}.cast(), {1}, {1})",
+                    "<_ as From<Vec<_>>>::from({vec}::from_raw_parts({}.cast(), {1}, {1}))",
                     operands[0], len
                 );
                 results.push(result);

crates/rust/tests/codegen.rs

@@ -31,3 +31,51 @@ mod inline_and_path {
         generate_all,
     });
 }
+
+#[allow(unused)]
+mod newtyped_list {
+    use std::ops::Deref;
+
+    wit_bindgen::generate!({
+        inline: r#"
+        package test:newtyped-list;
+
+        interface ntl {
+            type newtyped-list = list<u8>;
+            type typed-list = list<u8>;
+        }
+
+        world test {
+            use ntl.{newtyped-list, typed-list};
+            import use-newtyped-list: func(nl: newtyped-list) -> newtyped-list;
+            import use-typed-list: func(tl: typed-list) -> typed-list;
+            import use-list: func(l: list<u8>) -> list<u8>;
+        }
+        "#,
+        with: {
+            "test:newtyped-list/ntl/newtyped-list": NewtypedList,
+        }
+    });
+
+    struct NewtypedList(Vec<u8>);
+
+    impl Deref for NewtypedList {
+        type Target = Vec<u8>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl From<Vec<u8>> for NewtypedList {
+        fn from(value: Vec<u8>) -> Self {
+            NewtypedList(value)
+        }
+    }
+
+    impl From<NewtypedList> for Vec<u8> {
+        fn from(value: NewtypedList) -> Self {
+            value.0
+        }
+    }
+}