Handle fixed list with different API

Signed-off-by: James Sturtevant <[email protected]>

Author: jsturtevant

src/hyperlight_component_util/src/elaborate.rs

@@ -432,8 +432,8 @@ impl<'p, 'a> Ctx<'p, 'a> {
             ComponentDefinedType::Future(_) | ComponentDefinedType::Stream(_) => {
                 panic!("async not yet supported")
             }
-            ComponentDefinedType::FixedSizeList(vt, _) => {
-                Ok(Value::List(Box::new(self.elab_value(vt)?)))
+            ComponentDefinedType::FixedSizeList(vt, size) => {
+                Ok(Value::FixList(Box::new(self.elab_value(vt)?), *size))
             }
         }
     }

src/hyperlight_component_util/src/etypes.rs

@@ -83,6 +83,7 @@ pub enum Value<'a> {
     Char,
     String,
     List(Box<Value<'a>>),
+    FixList(Box<Value<'a>>, u32),
     Record(Vec<RecordField<'a>>),
     Tuple(Vec<Value<'a>>),
     Flags(Vec<Name<'a>>),

src/hyperlight_component_util/src/hl.rs

@@ -223,6 +223,20 @@ pub fn emit_hl_unmarshal_value(s: &mut State, id: Ident, vt: &Value) -> TokenStr
                 (#retid, cursor)
             }
         }
+        Value::FixList(vt, _size) => {
+            let inid = format_ident!("{}_elem", id);
+            let vtun = emit_hl_unmarshal_value(s, inid.clone(), vt);
+            quote! {
+                let mut cursor = 0;
+                let arr = ::core::array::from_fn(|_i| {
+                    let #inid = &#id[cursor..];
+                    let (x, b) = { #vtun };
+                    cursor += b;
+                    x
+                });
+                (arr, cursor)
+            }
+        }
         Value::Record(_) => panic!("record not at top level of valtype"),
         Value::Tuple(vts) => {
             let inid = format_ident!("{}_elem", id);
@@ -515,6 +529,25 @@ pub fn emit_hl_marshal_value(s: &mut State, id: Ident, vt: &Value) -> TokenStrea
                 #retid
             }
         }
+        Value::FixList(vt, _size) => {
+            // Optimize for byte arrays ie. [u8; N]
+            if matches!(vt.as_ref(), Value::S(_) | Value::U(_) | Value::F(_)) {
+                quote! {
+                    alloc::vec::Vec::from(#id.as_slice())
+                }
+            } else {
+                let retid = format_ident!("{}_fixlist", id);
+                let inid = format_ident!("{}_elem", id);
+                let vtun = emit_hl_marshal_value(s, inid.clone(), vt);
+                quote! {
+                    let mut #retid = alloc::vec::Vec::new();
+                    for #inid in #id {
+                        #retid.extend({ #vtun })
+                    }
+                    #retid
+                }
+            }
+        }
         Value::Record(_) => panic!("record not at top level of valtype"),
         Value::Tuple(vts) => {
             let retid = format_ident!("{}_tuple", id);

src/hyperlight_component_util/src/rtypes.rs

@@ -281,6 +281,11 @@ pub fn emit_value(s: &mut State, vt: &Value) -> TokenStream {
             let vt = emit_value(s, vt);
             quote! { alloc::vec::Vec<#vt> }
         }
+        Value::FixList(vt, size) => {
+            let vt = emit_value(s, vt);
+            let size = *size as usize;
+            quote! { [#vt; #size] }
+        }
         Value::Record(_) => panic!("record not at top level of valtype"),
         Value::Tuple(vts) => {
             let vts = vts.iter().map(|vt| emit_value(s, vt)).collect::<Vec<_>>();

src/hyperlight_component_util/src/substitute.rs

@@ -96,6 +96,7 @@ where
             Value::Char => Value::Char,
             Value::String => Value::String,
             Value::List(vt) => Value::List(Box::new(self.value(vt)?)),
+            Value::FixList(vt, size) => Value::FixList(Box::new(self.value(vt)?), *size),
             Value::Record(rfs) => Value::Record(self.record_fields(rfs)?),
             Value::Variant(vcs) => Value::Variant(self.variant_cases(vcs)?),
             Value::Flags(ns) => Value::Flags(ns.clone()),

src/hyperlight_component_util/src/wf.rs

@@ -213,6 +213,7 @@ impl<'p, 'a> Ctx<'p, 'a> {
             Value::Char => Ok(()),
             Value::String => Ok(()),
             Value::List(vt) => self.wf_value(p_, vt),
+            Value::FixList(vt, _) => self.wf_value(p_, vt),
             Value::Record(rfs) => anon_err.and(self.wf_record_fields(p_, rfs)),
             Value::Variant(vcs) => anon_err.and(self.wf_variant_cases(p_, vcs)),
             Value::Flags(ns) => anon_err.and(error_if_duplicates_by(

src/hyperlight_host/tests/wit_test.rs

@@ -155,7 +155,10 @@ impl test::wit::Roundtrip for Host {
     ) -> test::wit::roundtrip::Testenum {
         x
     }
-    fn roundtrip_fix_list(&mut self, x: Vec<u8>) -> Vec<u8> {
+    fn roundtrip_fix_list(&mut self, x: [u8; 4]) -> [u8; 4] {
+        x
+    }
+    fn roundtrip_fix_list_string(&mut self, x: [String; 4]) -> [String; 4] {
         x
     }
 
@@ -334,10 +337,11 @@ mod wit_test {
     make_test! { roundtrip_flags_large, in arb_largeflags() }
     make_test! { roundtrip_variant,     in arb_testvariant() }
     make_test! { roundtrip_enum,        in arb_testenum() }
-    make_test! { roundtrip_fix_list,    : Vec<u8> }
+    make_test! { roundtrip_fix_list,    : [u8; 4] }
+    make_test! { roundtrip_fix_list_string, : [String; 4] }
 
     #[test]
-    fn test_simple_func() {
+    fn test_roundtrip_no_result() {
         sb().roundtrip().roundtrip_no_result(42);
     }
 

src/tests/rust_guests/witguest/guest.wit

@@ -27,6 +27,7 @@ interface roundtrip {
   roundtrip-result: func(x: result<char, string>) -> result<char, string>;
   roundtrip-no-result: func(x: u32);
   roundtrip-fix-list: func(x: list<u8, 4>) -> list<u8, 4>;
+  roundtrip-fix-list-string: func(x: list<string, 4>) -> list<string, 4>;
 
   record testrecord {
     contents: string,

src/tests/rust_guests/witguest/src/main.rs

@@ -22,6 +22,7 @@ extern crate hyperlight_guest;
 
 mod bindings;
 use bindings::*;
+use alloc::string::String;
 
 struct Guest {}
 
@@ -113,9 +114,12 @@ impl test::wit::Roundtrip for Guest {
     ) -> test::wit::roundtrip::Testenum {
         (Host {}).roundtrip_enum(x)
     }
-    fn roundtrip_fix_list(&mut self, x: Vec<u8>) -> Vec<u8> {
+    fn roundtrip_fix_list(&mut self, x: [u8; 4]) -> [u8; 4] {
         (Host {}).roundtrip_fix_list(x)
     }
+    fn roundtrip_fix_list_string(&mut self, x: [String; 4]) -> [String; 4] {
+        (Host {}).roundtrip_fix_list_string(x)
+    }
     fn roundtrip_no_result(&mut self, x: u32) {
         (Host {}).roundtrip_no_result(x)
     }