wip: test more list types

Author: azdle

Cargo.lock

@@ -34,6 +34,7 @@ wit-bindgen = { path = '../guest-rust', features = ['async'] }
 test-helpers = { path = '../test-helpers' }
 # For use with the custom attributes test
 serde_json = "1"
+bytes = "*"
 
 [features]
 serde = ['dep:serde', 'wit-bindgen-core/serde']

crates/rust/Cargo.toml

@@ -814,7 +814,7 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 uwriteln!(self.src, "let e{tmp} = {body};");
                 uwriteln!(self.src, "{result}.push(e{tmp});");
                 uwriteln!(self.src, "}}");
-                results.push(result);
+                results.push(format!("<_ as From<Vec<_>>>::from({result})"));
                 let dealloc = self.r#gen.path_to_cabi_dealloc();
                 self.push_str(&format!(
                     "{dealloc}({base}, {len} * {size}, {align});\n",

crates/rust/src/bindgen.rs

@@ -34,6 +34,8 @@ mod inline_and_path {
 
 #[allow(unused)]
 mod newtyped_list {
+    use std::ops::Deref;
+
     wit_bindgen::generate!({
         inline: r#"
         package test:newtyped-list;
@@ -47,17 +49,60 @@ mod newtyped_list {
             use-list: func(l: list<u8>) -> list<u8>;
         }
 
+        interface ntl-bytes {
+            type newtyped-bytes-list = list<u8>;
+            type typed-bytes-list = list<u8>;
+
+            use-newtyped-bytes-list: func(nl: newtyped-bytes-list) -> newtyped-bytes-list;
+            use-typed-bytes-list: func(tl: typed-bytes-list) -> typed-bytes-list;
+            use-bytes-list: func(l: list<u8>) -> list<u8>;
+        }
+
+        interface ntl-noncopy {
+            // this will be new-typed by a non-copy struct
+            type noncopy-byte = u8;
+
+            type newtyped-noncopy-list = list<noncopy-byte>;
+            type typed-noncopy-list = list<noncopy-byte>;
+
+            use-newtyped-noncopy-list: func(nl: newtyped-noncopy-list) -> newtyped-noncopy-list;
+            use-typed-noncopy-list: func(tl: typed-noncopy-list) -> typed-noncopy-list;
+            use-noncopy-list: func(l: list<noncopy-byte>) -> list<noncopy-byte>;
+        }
+
+        interface ntl-noncanonical {
+            // tuples are non-canonical, but can implement copy
+            type noncanonical = tuple<u8,u8>;
+
+            type newtyped-noncanonical-list = list<noncanonical>;
+            type typed-noncanonical-list = list<noncanonical>;
+
+            use-newtyped-noncanonical-list: func(nl: newtyped-noncanonical-list) -> newtyped-noncanonical-list;
+            use-typed-noncanonical-list: func(tl: typed-noncanonical-list) -> typed-noncanonical-list;
+            use-noncanonical-list: func(l: list<noncanonical>) -> list<noncanonical>;
+        }
+
         world test {
             import ntl;
             export ntl;
+            import ntl-bytes;
+            export ntl-bytes;
+            import ntl-noncopy;
+            export ntl-noncopy;
+            import ntl-noncanonical;
+            export ntl-noncanonical;
         }
         "#,
         with: {
             "test:newtyped-list/ntl/newtyped-list": crate::newtyped_list::NewtypedList,
+            "test:newtyped-list/ntl-bytes/newtyped-bytes-list": bytes::Bytes,
+            "test:newtyped-list/ntl-noncopy/noncopy-byte": crate::newtyped_list::NoncopyByte,
+            "test:newtyped-list/ntl-noncopy/newtyped-noncopy-list": crate::newtyped_list::NewtypedNoncopyList,
+            "test:newtyped-list/ntl-noncanonical/newtyped-noncanonical-list": crate::newtyped_list::NewtypedNoncanonicalList,
         }
     });
 
-    struct NewtypedList(Vec<u8>);
+    pub struct NewtypedList(Vec<u8>);
 
     impl From<Vec<u8>> for NewtypedList {
         fn from(value: Vec<u8>) -> Self {
@@ -70,4 +115,49 @@ mod newtyped_list {
             value.0
         }
     }
+
+    pub struct NoncopyByte(u8);
+    pub struct NewtypedNoncopyList(Vec<String>);
+
+    impl From<Vec<String>> for NewtypedNoncopyList {
+        fn from(value: Vec<String>) -> Self {
+            NewtypedNoncopyList(value)
+        }
+    }
+
+    impl From<NewtypedNoncopyList> for Vec<String> {
+        fn from(value: NewtypedNoncopyList) -> Self {
+            value.0
+        }
+    }
+
+    impl Deref for NewtypedNoncopyList {
+        type Target = Vec<String>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    pub struct NewtypedNoncanonicalList(Vec<(u8, u8)>);
+
+    impl From<Vec<(u8, u8)>> for NewtypedNoncanonicalList {
+        fn from(value: Vec<(u8, u8)>) -> Self {
+            NewtypedNoncanonicalList(value)
+        }
+    }
+
+    impl From<NewtypedNoncanonicalList> for Vec<(u8, u8)> {
+        fn from(value: NewtypedNoncanonicalList) -> Self {
+            value.0
+        }
+    }
+
+    impl Deref for NewtypedNoncanonicalList {
+        type Target = Vec<(u8, u8)>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
 }