Bump wasmparser from 0.224.1 to 0.235.0

src/hyperlight_component_macro/Cargo.toml

@@ -16,7 +16,7 @@ name = "hyperlight_component_macro"
 proc-macro = true
 
 [dependencies]
-wasmparser = { version = "0.224.0" }
+wasmparser = { version = "0.235.0" }
 quote = { version = "1.0.38" }
 proc-macro2 = { version = "1.0.95" }
 syn = { version = "2.0.104" }

src/hyperlight_component_util/Cargo.toml

@@ -15,7 +15,7 @@ Shared implementation for the procedural macros that generate Hyperlight host an
 name = "hyperlight_component_util"
 
 [dependencies]
-wasmparser = { version = "0.224.0" }
+wasmparser = { version = "0.235.0" }
 quote = { version = "1.0.38" }
 proc-macro2 = { version = "1.0.95" }
 syn = { version = "2.0.104" }

src/hyperlight_component_util/src/elaborate.rs

@@ -24,14 +24,14 @@ limitations under the License.
 //! substitute.rs for more details of the approach here).
 
 use wasmparser::{
-    ComponentAlias, ComponentDefinedType, ComponentFuncResult, ComponentFuncType,
-    ComponentOuterAliasKind, ComponentType, ComponentTypeDeclaration, ComponentTypeRef,
-    ComponentValType, CompositeInnerType, CoreType, InstanceTypeDeclaration, ModuleTypeDeclaration,
-    OuterAliasKind, PrimitiveValType, TypeBounds, TypeRef,
+    ComponentAlias, ComponentDefinedType, ComponentFuncType, ComponentOuterAliasKind,
+    ComponentType, ComponentTypeDeclaration, ComponentTypeRef, ComponentValType,
+    CompositeInnerType, CoreType, InstanceTypeDeclaration, ModuleTypeDeclaration, OuterAliasKind,
+    PrimitiveValType, TypeBounds, TypeRef,
 };
 
 use crate::etypes::{
-    self, BoundedTyvar, Component, CoreDefined, CoreExportDecl, CoreExternDesc, CoreModule,
+    BoundedTyvar, Component, CoreDefined, CoreExportDecl, CoreExternDesc, CoreModule,
     CoreOrComponentExternDesc, Ctx, Defined, ExternDecl, ExternDesc, FloatWidth, Func, Handleable,
     Instance, IntWidth, Name, Param, QualifiedInstance, RecordField, Resource, ResourceId,
     TypeBound, Tyvar, Value, VariantCase,
@@ -366,6 +366,7 @@ impl<'p, 'a> Ctx<'p, 'a> {
                 PrimitiveValType::F64 => Value::F(FloatWidth::F64),
                 PrimitiveValType::Char => Value::Char,
                 PrimitiveValType::String => Value::String,
+                PrimitiveValType::ErrorContext => panic!("async not yet supported"),
             }),
         }
     }
@@ -428,9 +429,12 @@ impl<'p, 'a> Ctx<'p, 'a> {
                 Defined::Handleable(h) => Ok(Value::Borrow(h.clone())),
                 _ => Err(Error::HandleToNonResource),
             },
-            ComponentDefinedType::Future(_)
-            | ComponentDefinedType::Stream(_)
-            | ComponentDefinedType::ErrorContext => panic!("async not yet supported"),
+            ComponentDefinedType::Future(_) | ComponentDefinedType::Stream(_) => {
+                panic!("async not yet supported")
+            }
+            ComponentDefinedType::FixedSizeList(vt, _) => {
+                Ok(Value::List(Box::new(self.elab_value(vt)?)))
+            }
         }
     }
 
@@ -446,18 +450,9 @@ impl<'p, 'a> Ctx<'p, 'a> {
                     })
                 })
                 .collect::<Result<Vec<_>, Error<'a>>>()?,
-            result: match &ft.results {
-                ComponentFuncResult::Unnamed(vt) => etypes::Result::Unnamed(self.elab_value(vt)?),
-                ComponentFuncResult::Named(rs) => etypes::Result::Named(
-                    rs.iter()
-                        .map(|(n, vt)| {
-                            Ok(Param {
-                                name: Name { name: n },
-                                ty: self.elab_value(vt)?,
-                            })
-                        })
-                        .collect::<Result<Vec<_>, Error<'a>>>()?,
-                ),
+            result: match &ft.result {
+                Some(vt) => Some(self.elab_value(vt)?),
+                None => None,
             },
         })
     }

src/hyperlight_component_util/src/etypes.rs

@@ -136,17 +136,11 @@ pub struct Param<'a> {
     pub ty: Value<'a>,
 }
 
-#[derive(Debug, Clone)]
-pub enum Result<'a> {
-    Unnamed(Value<'a>),
-    Named(Vec<Param<'a>>),
-}
-
 /// functype_e in the specification
 #[derive(Debug, Clone)]
 pub struct Func<'a> {
     pub params: Vec<Param<'a>>,
-    pub result: Result<'a>,
+    pub result: Option<Value<'a>>,
 }
 
 /// In the spec, this does not exist, but a validation rule ensures an

src/hyperlight_component_util/src/hl.rs

@@ -19,7 +19,7 @@ use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
 
 use crate::emit::{State, kebab_to_cons, kebab_to_var};
-use crate::etypes::{self, Defined, Handleable, TypeBound, Tyvar, Value};
+use crate::etypes::{Defined, Handleable, TypeBound, Tyvar, Value};
 use crate::rtypes;
 
 /// Construct a string that can be used "on the wire" to identify a
@@ -653,14 +653,13 @@ pub fn emit_hl_unmarshal_param(s: &mut State, id: Ident, pt: &Value) -> TokenStr
 ///
 /// Precondition: the result type must only be a named result if there
 /// are no names in it (i.e. a unit type)
-pub fn emit_hl_unmarshal_result(s: &mut State, id: Ident, rt: &etypes::Result) -> TokenStream {
+pub fn emit_hl_unmarshal_result(s: &mut State, id: Ident, rt: &Option<Value<'_>>) -> TokenStream {
     match rt {
-        etypes::Result::Named(rs) if rs.is_empty() => quote! { () },
-        etypes::Result::Unnamed(vt) => {
+        Some(vt) => {
             let toks = emit_hl_unmarshal_value(s, id, vt);
             quote! { { #toks }.0 }
         }
-        _ => panic!("named results not supported"),
+        None => quote! { () },
     }
 }
 
@@ -678,13 +677,12 @@ pub fn emit_hl_marshal_param(s: &mut State, id: Ident, pt: &Value) -> TokenStrea
 ///
 /// Precondition: the result type must only be a named result if there
 /// are no names in it (a unit type)
-pub fn emit_hl_marshal_result(s: &mut State, id: Ident, rt: &etypes::Result) -> TokenStream {
+pub fn emit_hl_marshal_result(s: &mut State, id: Ident, rt: &Option<Value<'_>>) -> TokenStream {
     match rt {
-        etypes::Result::Named(rs) if rs.is_empty() => quote! { ::alloc::vec::Vec::new() },
-        etypes::Result::Unnamed(vt) => {
+        None => quote! { ::alloc::vec::Vec::new() },
+        Some(vt) => {
             let toks = emit_hl_marshal_value(s, id, vt);
             quote! { { #toks } }
         }
-        _ => panic!("named results not supported"),
     }
 }

src/hyperlight_component_util/src/rtypes.rs

@@ -30,7 +30,7 @@ use crate::emit::{
 };
 use crate::etypes::{
     Component, Defined, ExternDecl, ExternDesc, Func, Handleable, ImportExport, Instance, Param,
-    Result, TypeBound, Tyvar, Value,
+    TypeBound, Tyvar, Value,
 };
 
 /// When referring to an instance or resource trait, emit a token
@@ -521,11 +521,10 @@ pub fn emit_func_param(s: &mut State, p: &Param) -> TokenStream {
 ///
 /// Precondition: the result type must only be a named result if there
 /// are no names in it (i.e. a unit type)
-pub fn emit_func_result(s: &mut State, r: &Result) -> TokenStream {
+pub fn emit_func_result(s: &mut State, r: &Option<Value<'_>>) -> TokenStream {
     match r {
-        Result::Unnamed(vt) => emit_value(s, vt),
-        Result::Named(rs) if rs.is_empty() => quote! { () },
-        _ => panic!("multiple named function results are not currently supported"),
+        Some(vt) => emit_value(s, vt),
+        None => quote! { () },
     }
 }
 

src/hyperlight_component_util/src/substitute.rs

@@ -134,13 +134,10 @@ where
         pts.iter().map(|pt| self.param(pt)).collect()
     }
 
-    fn result(
-        &self,
-        rt: &crate::etypes::Result<'a>,
-    ) -> Result<crate::etypes::Result<'a>, Self::Error> {
+    fn result(&self, rt: &Option<Value<'a>>) -> Result<Option<Value<'a>>, Self::Error> {
         Ok(match rt {
-            crate::etypes::Result::Unnamed(vt) => crate::etypes::Result::Unnamed(self.value(vt)?),
-            crate::etypes::Result::Named(pts) => crate::etypes::Result::Named(self.params(pts)?),
+            Some(vt) => Some(self.value(vt)?),
+            None => None,
         })
     }
 

src/hyperlight_component_util/src/wf.rs

@@ -268,10 +268,8 @@ impl<'p, 'a> Ctx<'p, 'a> {
             .iter()
             .try_for_each(|fp: &'r Param<'a>| self.wf_value(param_pos, &fp.ty))?;
         match &ft.result {
-            crate::etypes::Result::Unnamed(vt) => self.wf_value(result_pos, vt),
-            crate::etypes::Result::Named(ps) => ps
-                .iter()
-                .try_for_each(|fp: &'r Param<'a>| self.wf_value(result_pos, &fp.ty)),
+            Some(vt) => self.wf_value(result_pos, vt),
+            None => Ok(()),
         }
     }
     fn wf_type_bound<'r>(