Merge branch 'main' into new_wasm_tools

Author: fibonacci1729

crates/wac-graph/src/graph.rs

@@ -543,6 +543,15 @@ impl CompositionGraph {
             "invalid package id"
         );
 
+        // Remove exports and definitions associated with the package before
+        // removing nodes, as retain_nodes invalidates the node indices.
+        self.exports
+            .retain(|_, n| self.graph[*n].package != Some(package));
+        self.defined
+            .retain(|_, n| self.graph[*n].package != Some(package));
+        self.imports
+            .retain(|_, n| self.graph[*n].package != Some(package));
+
         // Remove all nodes associated with the package
         self.graph
             .retain_nodes(|g, i| g[i].package != Some(package));
@@ -1959,4 +1968,34 @@ mod test {
             UnexportError::MustExportDefinition
         ));
     }
+
+    #[test]
+    fn it_cleans_up_exports_on_unregister_package() {
+        let mut graph = CompositionGraph::new();
+        let bytes = wat::parse_str(
+            r#"(component
+                (import "f" (func))
+                (export "g" (func 0))
+            )"#,
+        )
+        .unwrap();
+
+        let package =
+            wac_types::Package::from_bytes("test:pkg", None, bytes, graph.types_mut()).unwrap();
+        let pkg_id = graph.register_package(package).unwrap();
+
+        // Create an instantiation and export an alias
+        let inst_id = graph.instantiate(pkg_id);
+        let alias_id = graph.alias_instance_export(inst_id, "g").unwrap();
+        graph.export(alias_id, "g").unwrap();
+
+        assert!(graph.get_export("g").is_some());
+
+        // Unregistering the package should clean up exports
+        graph.unregister_package(pkg_id);
+        assert!(
+            graph.get_export("g").is_none(),
+            "exports should be cleaned up after unregister_package"
+        );
+    }
 }

crates/wac-parser/src/resolution.rs

@@ -2553,7 +2553,8 @@ impl<'a> AstResolver<'a> {
             }
 
             // Otherwise, project into the parent based on the current segment
-            let export = match found.unwrap() {
+            let Some(parent) = found else { break };
+            let export = match parent {
                 // The parent is an interface or instance
                 ItemKind::Type(Type::Interface(id)) | ItemKind::Instance(id) => {
                     state.graph.types()[id].exports.get(segment).copied()

crates/wac-parser/tests/resolution/fail/missing-package-definition.wac

@@ -0,0 +1,5 @@
+package test:comp;
+
+interface i {
+    use foo:bar/nonexistent.{a};
+}

crates/wac-parser/tests/resolution/fail/missing-package-definition.wac.result

@@ -0,0 +1,10 @@
+failed to resolve document
+
+  × package `foo:bar` has no export named `nonexistent`
+   ╭─[tests/resolution/fail/missing-package-definition.wac:4:17]
+ 3 │ interface i {
+ 4 │     use foo:bar/nonexistent.{a};
+   ·                 ─────┬─────
+   ·                      ╰── unknown export `nonexistent`
+ 5 │ }
+   ╰────

crates/wac-parser/tests/resolution/fail/missing-package-definition/foo/bar.wat

@@ -0,0 +1,3 @@
+(component
+  (import "foo" (func))
+)

crates/wac-resolver/src/registry.rs

@@ -153,7 +153,9 @@ impl RegistryPackageResolver {
         let mut finished = 0;
 
         while let Some(res) = tasks.next().await {
-            let (index, download) = res.unwrap()?;
+            let (index, download) = res.map_err(|e| Error::RegistryDownloadFailure {
+                source: anyhow::anyhow!("download task panicked: {e}"),
+            })??;
 
             finished += 1;
 

crates/wac-types/src/aggregator.rs

@@ -227,7 +227,7 @@ impl TypeAggregator {
                 // We'll remap the source below and replace
                 checker
                     .is_subtype(*source_kind, types, target_kind, &self.types)
-                    .with_context(|| format!("mismatched type for export `{name}`"))?;
+                    .with_context(|| format!("mismatched type for import `{name}`"))?;
             }
 
             let remapped = self.remap_item_kind(types, *source_kind, checker)?;

crates/wac-types/src/checker.rs

@@ -411,15 +411,15 @@ impl<'a> SubtypeChecker<'a> {
                     element_type: ae,
                     initial: ai,
                     maximum: am,
-                    table64: _a64,
-                    shared: _ashared,
+                    table64: a64,
+                    shared: ashared,
                 },
                 CoreExtern::Table {
                     element_type: be,
                     initial: bi,
                     maximum: bm,
-                    table64: _b64,
-                    shared: _bshared,
+                    table64: b64,
+                    shared: bshared,
                 },
             ) => {
                 if ae != be {
@@ -431,6 +431,14 @@ impl<'a> SubtypeChecker<'a> {
                     bail!("mismatched table limits");
                 }
 
+                if a64 != b64 {
+                    bail!("mismatched table64 flag for tables");
+                }
+
+                if ashared != bshared {
+                    bail!("mismatched shared flag for tables");
+                }
+
                 Ok(())
             }
             (
@@ -439,14 +447,14 @@ impl<'a> SubtypeChecker<'a> {
                     shared: ashared,
                     initial: ai,
                     maximum: am,
-                    page_size_log2: _apsl,
+                    page_size_log2: apsl,
                 },
                 CoreExtern::Memory {
                     memory64: b64,
                     shared: bshared,
                     initial: bi,
                     maximum: bm,
-                    page_size_log2: _bpsl,
+                    page_size_log2: bpsl,
                 },
             ) => {
                 if ashared != bshared {
@@ -461,18 +469,22 @@ impl<'a> SubtypeChecker<'a> {
                     bail!("mismatched memory limits");
                 }
 
+                if apsl != bpsl {
+                    bail!("mismatched page_size_log2 for memories");
+                }
+
                 Ok(())
             }
             (
                 CoreExtern::Global {
                     val_type: avt,
                     mutable: am,
-                    shared: _ashared,
+                    shared: ashared,
                 },
                 CoreExtern::Global {
                     val_type: bvt,
                     mutable: bm,
-                    shared: _bshared,
+                    shared: bshared,
                 },
             ) => {
                 if am != bm {
@@ -484,6 +496,10 @@ impl<'a> SubtypeChecker<'a> {
                     bail!("expected global type {expected}, found {found}");
                 }
 
+                if ashared != bshared {
+                    bail!("mismatched shared flag for globals");
+                }
+
                 Ok(())
             }
             (CoreExtern::Tag(a), CoreExtern::Tag(b)) => self.core_func(a, at, b, bt),
@@ -795,3 +811,95 @@ impl<'a> SubtypeChecker<'a> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{CoreRefType, CoreType, HeapType};
+
+    fn check_core_extern(a: &CoreExtern, b: &CoreExtern) -> Result<()> {
+        let types = Types::default();
+        let mut cache = HashSet::new();
+        let checker = SubtypeChecker::new(&mut cache);
+        checker.core_extern(a, &types, b, &types)
+    }
+
+    fn base_table() -> CoreExtern {
+        CoreExtern::Table {
+            element_type: CoreRefType {
+                nullable: true,
+                heap_type: HeapType::Func,
+            },
+            initial: 1,
+            maximum: None,
+            table64: false,
+            shared: false,
+        }
+    }
+
+    #[test]
+    fn mismatched_table64_is_rejected() {
+        let a = base_table();
+        let mut b = base_table();
+        if let CoreExtern::Table { table64, .. } = &mut b {
+            *table64 = true;
+        }
+        assert!(
+            check_core_extern(&a, &b).is_err(),
+            "mismatched table64 should be rejected"
+        );
+    }
+
+    #[test]
+    fn mismatched_table_shared_is_rejected() {
+        let a = base_table();
+        let mut b = base_table();
+        if let CoreExtern::Table { shared, .. } = &mut b {
+            *shared = true;
+        }
+        assert!(
+            check_core_extern(&a, &b).is_err(),
+            "mismatched table shared should be rejected"
+        );
+    }
+
+    #[test]
+    fn mismatched_memory_page_size_log2_is_rejected() {
+        let a = CoreExtern::Memory {
+            memory64: false,
+            shared: false,
+            initial: 1,
+            maximum: None,
+            page_size_log2: Some(16),
+        };
+        let b = CoreExtern::Memory {
+            memory64: false,
+            shared: false,
+            initial: 1,
+            maximum: None,
+            page_size_log2: Some(14),
+        };
+        assert!(
+            check_core_extern(&a, &b).is_err(),
+            "mismatched page_size_log2 should be rejected"
+        );
+    }
+
+    #[test]
+    fn mismatched_global_shared_is_rejected() {
+        let a = CoreExtern::Global {
+            val_type: CoreType::I32,
+            mutable: false,
+            shared: false,
+        };
+        let b = CoreExtern::Global {
+            val_type: CoreType::I32,
+            mutable: false,
+            shared: true,
+        };
+        assert!(
+            check_core_extern(&a, &b).is_err(),
+            "mismatched global shared should be rejected"
+        );
+    }
+}