Update wasm-tools to v1.224.0

karthik2804 · kate-goldenring · karthik2804 · commit ae28c90c22c8 · 2025-02-05T09:04:44.000-05:00
Co-authored-by: Kate Goldenring &lt;kate.goldenring@fermyon.com&gt;
Signed-off-by: karthik2804 &lt;karthik.ganeshram@fermyon.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -47,7 +47,12 @@ wit-component = { workspace = true }
 default = ["wit", "registry"]
 wat = ["wac-resolver/wat"]
 wit = ["wac-resolver/wit"]
-registry = ["wac-resolver/registry", "dep:indicatif", "dep:warg-client", "dep:warg-protocol"]
+registry = [
+    "wac-resolver/registry",
+    "dep:indicatif",
+    "dep:warg-client",
+    "dep:warg-protocol",
+]
 native-tls-vendored = ["warg-client?/native-tls-vendored"]
 
 [workspace]
@@ -58,12 +63,12 @@ wac-parser = { path = "crates/wac-parser", version = "0.7.0-dev", default-featur
 wac-resolver = { path = "crates/wac-resolver", version = "0.7.0-dev", default-features = false }
 wac-graph = { path = "crates/wac-graph", version = "0.7.0-dev" }
 wac-types = { path = "crates/wac-types", version = "0.7.0-dev" }
-wit-parser = "0.202.0"
-wasmparser = "0.202.0"
-wit-component = "0.202.0"
-wasm-encoder = "0.202.0"
-wasmprinter = "0.202.0"
-wasm-metadata = "0.202.0"
+wit-parser = "0.224.0"
+wasmparser = "0.224.0"
+wit-component = "0.224.0"
+wasm-encoder = "0.224.0"
+wasmprinter = "0.224.0"
+wasm-metadata = "0.224.0"
 anyhow = "1.0.81"
 clap = { version = "4.5.4", features = ["derive"] }
 semver = { version = "1.0.22", features = ["serde"] }
@@ -78,7 +83,7 @@ indexmap = { version = "2.2.6", features = ["serde"] }
 id-arena = "2.2.1"
 serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.115"
-wat = "1.202.0"
+wat = "1.224.0"
 logos = "0.14.0"
 miette = "7.2.0"
 thiserror = "1.0.58"
diff --git a/crates/wac-graph/src/encoding.rs b/crates/wac-graph/src/encoding.rs
@@ -8,9 +8,10 @@ use wac_types::{
     Variant, WorldId,
 };
 use wasm_encoder::{
-    Alias, ComponentBuilder, ComponentExportKind, ComponentOuterAliasKind, ComponentType,
-    ComponentTypeEncoder, ComponentTypeRef, ComponentValType, CoreTypeEncoder, EntityType,
-    GlobalType, InstanceType, MemoryType, ModuleType, TableType, TagKind, TagType, TypeBounds,
+    Alias, ComponentBuilder, ComponentCoreTypeEncoder, ComponentExportKind,
+    ComponentOuterAliasKind, ComponentType, ComponentTypeEncoder, ComponentTypeRef,
+    ComponentValType, EntityType, GlobalType, InstanceType, MemoryType, ModuleType, TableType,
+    TagKind, TagType, TypeBounds,
 };
 
 /// A type used to abstract the API differences between a component builder,
@@ -55,7 +56,7 @@ impl Encodable {
         }
     }
 
-    fn core_type(&mut self) -> CoreTypeEncoder {
+    fn core_type(&mut self) -> ComponentCoreTypeEncoder {
         match self {
             Encodable::Builder(t) => t.core_type().1,
             Encodable::Instance(t) => t.core_type(),
@@ -268,6 +269,9 @@ impl<'a> TypeEncoder<'a> {
             DefinedType::Alias(ValueType::Borrow(id)) => self.borrow(state, *id),
             DefinedType::Alias(ValueType::Own(id)) => self.own(state, *id),
             DefinedType::Alias(ValueType::Defined(id)) => self.defined(state, *id),
+            DefinedType::Stream(ty) => self.stream(state, *ty),
+            DefinedType::Future(ty) => self.future(state, *ty),
+            DefinedType::ErrorContext => self.error_context(state),
         };
 
         log::debug!("defined type encoded to type index {index}");
@@ -476,25 +480,36 @@ impl<'a> TypeEncoder<'a> {
                 element_type,
                 initial,
                 maximum,
+                table64,
+                shared,
             } => EntityType::Table(TableType {
                 element_type: (*element_type).into(),
                 minimum: *initial,
                 maximum: *maximum,
+                table64: *table64,
+                shared: *shared,
             }),
             CoreExtern::Memory {
                 memory64,
                 shared,
                 initial,
                 maximum,
+                page_size_log2,
             } => EntityType::Memory(MemoryType {
                 minimum: *initial,
                 maximum: *maximum,
                 memory64: *memory64,
                 shared: *shared,
+                page_size_log2: *page_size_log2,
             }),
-            CoreExtern::Global { val_type, mutable } => EntityType::Global(GlobalType {
+            CoreExtern::Global {
+                val_type,
+                mutable,
+                shared,
+            } => EntityType::Global(GlobalType {
                 val_type: (*val_type).into(),
                 mutable: *mutable,
+                shared: *shared,
             }),
             CoreExtern::Tag(func) => {
                 let index = encodable.type_count();
@@ -554,6 +569,26 @@ impl<'a> TypeEncoder<'a> {
         index
     }
 
+    fn stream(&self, state: &mut State, ty: Option<ValueType>) -> u32 {
+        let ty = ty.map(|ty| self.value_type(state, ty));
+        let index = state.current.encodable.type_count();
+        state.current.encodable.ty().defined_type().stream(ty);
+        index
+    }
+
+    fn future(&self, state: &mut State, ty: Option<ValueType>) -> u32 {
+        let ty = ty.map(|ty| self.value_type(state, ty));
+        let index = state.current.encodable.type_count();
+        state.current.encodable.ty().defined_type().future(ty);
+        index
+    }
+
+    fn error_context(&self, state: &mut State) -> u32 {
+        let index = state.current.encodable.type_count();
+        state.current.encodable.ty().defined_type().error_context();
+        index
+    }
+
     fn option(&self, state: &mut State, ty: ValueType) -> u32 {
         let ty = self.value_type(state, ty);
         let index = state.current.encodable.type_count();
diff --git a/crates/wac-graph/tests/encoding.rs b/crates/wac-graph/tests/encoding.rs
@@ -133,7 +133,11 @@ impl GraphFile {
             )
         })?;
 
-        let mut module = wit_component::dummy_module(&resolve, world);
+        let mut module = wit_component::dummy_module(
+            &resolve,
+            world,
+            wit_parser::ManglingAndAbi::Legacy(wit_parser::LiftLowerAbi::Sync),
+        );
         wit_component::embed_component_metadata(
             &mut module,
             &resolve,
@@ -147,7 +151,7 @@ impl GraphFile {
         )
         })?;
 
-        let encoder = ComponentEncoder::default().validate(true).module(&module)?;
+        let mut encoder = ComponentEncoder::default().validate(true).module(&module)?;
         encoder
             .encode()
             .with_context(|| format!("failed to encode a component from module derived from package `{path}` for test case `{test_case}`", path = path.display()))
diff --git a/crates/wac-parser/src/ast/expr.rs b/crates/wac-parser/src/ast/expr.rs
@@ -237,7 +237,7 @@ impl Peek for InstantiationArgumentName<'_> {
     }
 }
 
-impl<'a> InstantiationArgumentName<'a> {
+impl InstantiationArgumentName<'_> {
     /// Gets the span of the instantiation argument name.
     pub fn span(&self) -> SourceSpan {
         match self {
@@ -288,7 +288,7 @@ pub enum PostfixExpr<'a> {
     NamedAccess(NamedAccessExpr<'a>),
 }
 
-impl<'a> PostfixExpr<'a> {
+impl PostfixExpr<'_> {
     /// Gets the span of the postfix expression.
     pub fn span(&self) -> SourceSpan {
         match self {
diff --git a/crates/wac-parser/src/ast/type.rs b/crates/wac-parser/src/ast/type.rs
@@ -672,7 +672,7 @@ pub enum Type<'a> {
     Ident(Ident<'a>),
 }
 
-impl<'a> Type<'a> {
+impl Type<'_> {
     /// Gets the span of the type.
     pub fn span(&self) -> SourceSpan {
         match self {
diff --git a/crates/wac-parser/src/lexer.rs b/crates/wac-parser/src/lexer.rs
@@ -516,7 +516,7 @@ impl<'a> Lexer<'a> {
     }
 }
 
-impl<'a> Iterator for Lexer<'a> {
+impl Iterator for Lexer<'_> {
     type Item = (LexerResult<Token>, SourceSpan);
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/crates/wac-parser/src/resolution.rs b/crates/wac-parser/src/resolution.rs
@@ -664,7 +664,7 @@ pub struct Resolution<'a> {
     instantiation_spans: HashMap<NodeId, SourceSpan>,
 }
 
-impl<'a> Resolution<'a> {
+impl Resolution<'_> {
     /// Gets the document that was resolved.
     pub fn document(&self) -> &Document {
         self.document
diff --git a/crates/wac-resolver/Cargo.toml b/crates/wac-resolver/Cargo.toml
@@ -34,9 +34,16 @@ warg-server = { workspace = true }
 pretty_assertions = { workspace = true }
 tokio-util = "0.7.10"
 tempdir = "0.3.7"
+tempfile = "3.2.0"
 
 [features]
 default = ["registry"]
 wat = ["dep:wat"]
 wit = ["dep:wit-parser"]
-registry = ["dep:warg-client", "dep:warg-protocol", "dep:warg-crypto", "dep:tokio", "dep:futures"]
+registry = [
+    "dep:warg-client",
+    "dep:warg-protocol",
+    "dep:warg-crypto",
+    "dep:tokio",
+    "dep:futures",
+]
diff --git a/crates/wac-resolver/src/fs.rs b/crates/wac-resolver/src/fs.rs
@@ -95,17 +95,15 @@ impl FileSystemPackageResolver {
                     let (pkg, _) = resolve.push_dir(&path).map_err(pkg_res_failure)?;
                     Some(pkg)
                 } else if path.extension().and_then(std::ffi::OsStr::to_str) == Some("wit") {
-                    let unresolved = wit_parser::UnresolvedPackage::parse_file(&path)
-                        .map_err(pkg_res_failure)?;
-                    let pkg = resolve.push(unresolved).map_err(pkg_res_failure)?;
+                    let pkg = resolve.push_file(&path).map_err(pkg_res_failure)?;
                     Some(pkg)
                 } else {
                     None
                 };
                 if let Some(pkg) = pkg {
                     packages.insert(
                         *key,
-                        wit_component::encode(Some(true), &resolve, pkg)
+                        wit_component::encode(&resolve, pkg)
                             .with_context(|| {
                                 format!(
                                     "failed to encode WIT package from `{path}`",
diff --git a/crates/wac-resolver/tests/support/mod.rs b/crates/wac-resolver/tests/support/mod.rs
@@ -9,7 +9,7 @@ use warg_client::{
 use warg_crypto::signing::PrivateKey;
 use warg_protocol::{operator::NamespaceState, registry::PackageName};
 use warg_server::{policy::content::WasmContentPolicy, Config, Server};
-use wit_parser::{Resolve, UnresolvedPackage};
+use wit_parser::Resolve;
 
 pub fn test_operator_key() -> &'static str {
     "ecdsa-p256:I+UlDo0HxyBBFeelhPPWmD+LnklOpqZDkrFP5VduASk="
@@ -43,16 +43,17 @@ pub async fn publish_wit(
     wit: &str,
     init: bool,
 ) -> Result<()> {
+    use std::io::Write;
     let mut resolve = Resolve::new();
+    let mut tmp = tempfile::NamedTempFile::new()?;
+    tmp.write(wit.as_bytes())?;
+    let path = tmp.path();
     let pkg = resolve
-        .push(
-            UnresolvedPackage::parse(Path::new("foo.wit"), wit)
-                .context("failed to parse wit for publishing")?,
-        )
+        .push_file(path)
         .context("failed to resolve wit for publishing")?;
 
-    let bytes = wit_component::encode(Some(true), &resolve, pkg)
-        .context("failed to encode wit for publishing")?;
+    let bytes =
+        wit_component::encode(&resolve, pkg).context("failed to encode wit for publishing")?;
 
     publish(config, &name.parse()?, version, bytes, init).await
 }
diff --git a/crates/wac-types/src/aggregator.rs b/crates/wac-types/src/aggregator.rs
@@ -842,6 +842,9 @@ impl TypeAggregator {
             DefinedType::Alias(ty) => {
                 DefinedType::Alias(self.remap_value_type(types, *ty, checker)?)
             }
+            DefinedType::Stream(s) => DefinedType::Stream(*s),
+            DefinedType::Future(f) => DefinedType::Future(*f),
+            DefinedType::ErrorContext => DefinedType::ErrorContext,
         };
 
         let remapped = self.types.add_defined_type(defined);
diff --git a/crates/wac-types/src/checker.rs b/crates/wac-types/src/checker.rs
@@ -422,11 +422,15 @@ impl<'a> SubtypeChecker<'a> {
                     element_type: ae,
                     initial: ai,
                     maximum: am,
+                    table64: _a64,
+                    shared: _ashared,
                 },
                 CoreExtern::Table {
                     element_type: be,
                     initial: bi,
                     maximum: bm,
+                    table64: _b64,
+                    shared: _bshared,
                 },
             ) => {
                 if ae != be {
@@ -446,12 +450,14 @@ impl<'a> SubtypeChecker<'a> {
                     shared: ashared,
                     initial: ai,
                     maximum: am,
+                    page_size_log2: _apsl,
                 },
                 CoreExtern::Memory {
                     memory64: b64,
                     shared: bshared,
                     initial: bi,
                     maximum: bm,
+                    page_size_log2: _bpsl,
                 },
             ) => {
                 if ashared != bshared {
@@ -472,10 +478,12 @@ impl<'a> SubtypeChecker<'a> {
                 CoreExtern::Global {
                     val_type: avt,
                     mutable: am,
+                    shared: _ashared,
                 },
                 CoreExtern::Global {
                     val_type: bvt,
                     mutable: bm,
+                    shared: _bshared,
                 },
             ) => {
                 if am != bm {
diff --git a/crates/wac-types/src/component.rs b/crates/wac-types/src/component.rs
diff --git a/crates/wac-types/src/core.rs b/crates/wac-types/src/core.rs
diff --git a/crates/wac-types/src/package.rs b/crates/wac-types/src/package.rs
diff --git a/src/commands/targets.rs b/src/commands/targets.rs

Original file line number	Diff line number	Diff line change
`@@ -237,7 +237,7 @@ impl Peek for InstantiationArgumentName<'_> {`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`
`240`		`-impl<'a> InstantiationArgumentName<'a> {`
	`240`	`+impl InstantiationArgumentName<'_> {`
`241`	`241`	`/// Gets the span of the instantiation argument name.`
`242`	`242`	`pub fn span(&self) -> SourceSpan {`
`243`	`243`	`match self {`
`@@ -288,7 +288,7 @@ pub enum PostfixExpr<'a> {`
`288`	`288`	`NamedAccess(NamedAccessExpr<'a>),`
`289`	`289`	`}`
`290`	`290`
`291`		`-impl<'a> PostfixExpr<'a> {`
	`291`	`+impl PostfixExpr<'_> {`
`292`	`292`	`/// Gets the span of the postfix expression.`
`293`	`293`	`pub fn span(&self) -> SourceSpan {`
`294`	`294`	`match self {`
Original file line number	Diff line number	Diff line change
`@@ -672,7 +672,7 @@ pub enum Type<'a> {`
`672`	`672`	`Ident(Ident<'a>),`
`673`	`673`	`}`
`674`	`674`
`675`		`-impl<'a> Type<'a> {`
	`675`	`+impl Type<'_> {`
`676`	`676`	`/// Gets the span of the type.`
`677`	`677`	`pub fn span(&self) -> SourceSpan {`
`678`	`678`	`match self {`
Original file line number	Diff line number	Diff line change
`@@ -516,7 +516,7 @@ impl<'a> Lexer<'a> {`
`516`	`516`	`}`
`517`	`517`	`}`
`518`	`518`
`519`		`-impl<'a> Iterator for Lexer<'a> {`
	`519`	`+impl Iterator for Lexer<'_> {`
`520`	`520`	`type Item = (LexerResult<Token>, SourceSpan);`
`521`	`521`
`522`	`522`	`fn next(&mut self) -> Option<Self::Item> {`
Original file line number	Diff line number	Diff line change
`@@ -664,7 +664,7 @@ pub struct Resolution<'a> {`
`664`	`664`	`instantiation_spans: HashMap<NodeId, SourceSpan>,`
`665`	`665`	`}`
`666`	`666`
`667`		`-impl<'a> Resolution<'a> {`
	`667`	`+impl Resolution<'_> {`
`668`	`668`	`/// Gets the document that was resolved.`
`669`	`669`	`pub fn document(&self) -> &Document {`
`670`	`670`	`self.document`