Handle fixed list with different API

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

Author: jsturtevant

src/hyperlight_component_util/src/elaborate.rs

@@ -429,12 +429,12 @@ impl<'p, 'a> Ctx<'p, 'a> {
                 Defined::Handleable(h) => Ok(Value::Borrow(h.clone())),
                 _ => Err(Error::HandleToNonResource),
             },
+            ComponentDefinedType::FixedSizeList(vt, size) => {
+                Ok(Value::FixList(Box::new(self.elab_value(vt)?), *size))
+            }
             ComponentDefinedType::Future(_) | ComponentDefinedType::Stream(_) => {
                 panic!("async not yet supported")
             }
-            ComponentDefinedType::FixedSizeList(vt, _) => {
-                Ok(Value::List(Box::new(self.elab_value(vt)?)))
-            }
         }
     }
 
@@ -450,10 +450,11 @@ impl<'p, 'a> Ctx<'p, 'a> {
                     })
                 })
                 .collect::<Result<Vec<_>, Error<'a>>>()?,
-            result: match &ft.result {
-                Some(vt) => Some(self.elab_value(vt)?),
-                None => None,
-            },
+            result: ft
+                .result
+                .as_ref()
+                .map(|vt| self.elab_value(vt))
+                .transpose()?,
         })
     }
 

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, _) => {
+            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,18 @@ pub fn emit_hl_marshal_value(s: &mut State, id: Ident, vt: &Value) -> TokenStrea
                 #retid
             }
         }
+        Value::FixList(vt, _size) => {
+            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,46 @@ 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_u32(&mut self, x: [u32; 4]) -> [u32; 4] {
+        x
+    }
+    fn roundtrip_fix_list_u64(&mut self, x: [u64; 4]) -> [u64; 4] {
+        x
+    }
+    fn roundtrip_fix_list_i8(&mut self, x: [i8; 4]) -> [i8; 4] {
+        x
+    }
+    fn roundtrip_fix_list_i16(&mut self, x: [i16; 4]) -> [i16; 4] {
+        x
+    }
+    fn roundtrip_fix_list_i32(&mut self, x: [i32; 4]) -> [i32; 4] {
+        x
+    }
+    fn roundtrip_fix_list_i64(&mut self, x: [i64; 4]) -> [i64; 4] {
+        x
+    }
+    fn roundtrip_fix_list_f32(&mut self, x: [f32; 4]) -> [f32; 4] {
+        x
+    }
+    fn roundtrip_fix_list_f64(&mut self, x: [f64; 4]) -> [f64; 4] {
+        x
+    }
+    fn roundtrip_fix_list_u8_size8(&mut self, x: [u8; 8]) -> [u8; 8] {
+        x
+    }
+    fn roundtrip_fix_list_u64_size2(&mut self, x: [u64; 2]) -> [u64; 2] {
+        x
+    }
+    fn roundtrip_fix_list_string(&mut self, x: [String; 4]) -> [String; 4] {
+        x
+    }
+    fn roundtrip_fix_array_of_lists(&mut self, x: [Vec<u8>; 3]) -> [Vec<u8>; 3] {
+        x
+    }
+    fn roundtrip_fix_array_of_string_lists(&mut self, x: [Vec<String>; 2]) -> [Vec<String>; 2] {
         x
     }
 
@@ -334,10 +373,23 @@ 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_u32, : [u32; 4] }
+    make_test! { roundtrip_fix_list_u64, : [u64; 4] }
+    make_test! { roundtrip_fix_list_i8,  : [i8; 4] }
+    make_test! { roundtrip_fix_list_i16, : [i16; 4] }
+    make_test! { roundtrip_fix_list_i32, : [i32; 4] }
+    make_test! { roundtrip_fix_list_i64, : [i64; 4] }
+    make_test! { roundtrip_fix_list_f32, : [f32; 4] }
+    make_test! { roundtrip_fix_list_f64, : [f64; 4] }
+    make_test! { roundtrip_fix_list_u8_size8, : [u8; 8] }
+    make_test! { roundtrip_fix_list_u64_size2, : [u64; 2] }
+    make_test! { roundtrip_fix_list_string, : [String; 4] }
+    make_test! { roundtrip_fix_array_of_lists, : [Vec<u8>; 3] }
+    make_test! { roundtrip_fix_array_of_string_lists, : [Vec<String>; 2] }
 
     #[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,19 @@ 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-u32: func(x: list<u32, 4>) -> list<u32, 4>;
+  roundtrip-fix-list-u64: func(x: list<u64, 4>) -> list<u64, 4>;
+  roundtrip-fix-list-i8: func(x: list<s8, 4>) -> list<s8, 4>;
+  roundtrip-fix-list-i16: func(x: list<s16, 4>) -> list<s16, 4>;
+  roundtrip-fix-list-i32: func(x: list<s32, 4>) -> list<s32, 4>;
+  roundtrip-fix-list-i64: func(x: list<s64, 4>) -> list<s64, 4>;
+  roundtrip-fix-list-f32: func(x: list<f32, 4>) -> list<f32, 4>;
+  roundtrip-fix-list-f64: func(x: list<f64, 4>) -> list<f64, 4>;
+  roundtrip-fix-list-u8-size8: func(x: list<u8, 8>) -> list<u8, 8>;
+  roundtrip-fix-list-u64-size2: func(x: list<u64, 2>) -> list<u64, 2>;
+  roundtrip-fix-list-string: func(x: list<string, 4>) -> list<string, 4>;
+  roundtrip-fix-array-of-lists: func(x: list<list<u8>, 3>) -> list<list<u8>, 3>;
+  roundtrip-fix-array-of-string-lists: func(x: list<list<string>, 2>) -> list<list<string>, 2>;
 
   record testrecord {
     contents: string,

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

@@ -21,6 +21,8 @@ extern crate alloc;
 extern crate hyperlight_guest;
 
 mod bindings;
+use alloc::string::String;
+
 use bindings::*;
 
 struct Guest {}
@@ -113,9 +115,48 @@ 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_u32(&mut self, x: [u32; 4]) -> [u32; 4] {
+        (Host {}).roundtrip_fix_list_u32(x)
+    }
+    fn roundtrip_fix_list_u64(&mut self, x: [u64; 4]) -> [u64; 4] {
+        (Host {}).roundtrip_fix_list_u64(x)
+    }
+    fn roundtrip_fix_list_i8(&mut self, x: [i8; 4]) -> [i8; 4] {
+        (Host {}).roundtrip_fix_list_i8(x)
+    }
+    fn roundtrip_fix_list_i16(&mut self, x: [i16; 4]) -> [i16; 4] {
+        (Host {}).roundtrip_fix_list_i16(x)
+    }
+    fn roundtrip_fix_list_i32(&mut self, x: [i32; 4]) -> [i32; 4] {
+        (Host {}).roundtrip_fix_list_i32(x)
+    }
+    fn roundtrip_fix_list_i64(&mut self, x: [i64; 4]) -> [i64; 4] {
+        (Host {}).roundtrip_fix_list_i64(x)
+    }
+    fn roundtrip_fix_list_f32(&mut self, x: [f32; 4]) -> [f32; 4] {
+        (Host {}).roundtrip_fix_list_f32(x)
+    }
+    fn roundtrip_fix_list_f64(&mut self, x: [f64; 4]) -> [f64; 4] {
+        (Host {}).roundtrip_fix_list_f64(x)
+    }
+    fn roundtrip_fix_list_u8_size8(&mut self, x: [u8; 8]) -> [u8; 8] {
+        (Host {}).roundtrip_fix_list_u8_size8(x)
+    }
+    fn roundtrip_fix_list_u64_size2(&mut self, x: [u64; 2]) -> [u64; 2] {
+        (Host {}).roundtrip_fix_list_u64_size2(x)
+    }
+    fn roundtrip_fix_list_string(&mut self, x: [String; 4]) -> [String; 4] {
+        (Host {}).roundtrip_fix_list_string(x)
+    }
+    fn roundtrip_fix_array_of_lists(&mut self, x: [Vec<u8>; 3]) -> [Vec<u8>; 3] {
+        x
+    }
+    fn roundtrip_fix_array_of_string_lists(&mut self, x: [Vec<String>; 2]) -> [Vec<String>; 2] {
+        x
+    }
     fn roundtrip_no_result(&mut self, x: u32) {
         (Host {}).roundtrip_no_result(x)
     }