Also include interfaces imported implicitly through uses in check

Signed-off-by: Ryan Levick <ryan.levick@fermyon.com>

Author: rylev

crates/wac-parser/src/resolution.rs

@@ -2712,15 +2712,17 @@ impl<'a> AstResolver<'a> {
         world: WorldId,
     ) -> ResolutionResult<()> {
         let world = &state.graph.types()[world];
+        // The interfaces imported implicitly through uses.
+        let implicit_imported_interfaces = world.implicit_imported_interfaces(state.graph.types());
         let mut cache = Default::default();
         let mut checker = SubtypeChecker::new(&mut cache);
 
         // The output is allowed to import a subset of the world's imports
         checker.invert();
         for (name, item_kind, import_node) in state.graph.imports() {
-            let expected = world
-                .imports
+            let expected = implicit_imported_interfaces
                 .get(name)
+                .or_else(|| world.imports.get(name))
                 .ok_or_else(|| Error::ImportNotInTarget {
                     name: name.to_owned(),
                     world: path.string.to_owned(),

crates/wac-parser/tests/resolution/fail/targets-implicit-imports.wac

@@ -2,7 +2,9 @@ package test:comp targets test:comp/foo;
 
 interface indirect-dependency {
     variant my-variant {
-        foo
+        foo,
+        // Extra variant that the instance does not have
+        bar
     }
 }
 
@@ -13,7 +15,7 @@ interface direct-dependency {
 }
 
 world foo {   
-    import a: direct-dependency;
+    import direct-dependency;
 }
 
 

crates/wac-parser/tests/resolution/fail/targets-implicit-imports.wac.result

@@ -1,4 +1,5 @@
 failed to resolve document
 
-  × import `a` has a mismatched type for target world `test:comp/foo`
-  ╰─▶ expected instance, found function
+  × import `test:comp/indirect-dependency` has a mismatched type for target world `test:comp/foo`
+  ├─▶ mismatched type for export `my-variant`
+  ╰─▶ expected a variant case count of 2, found a count of 1

crates/wac-parser/tests/resolution/fail/targets-implicit-imports/foo/bar.wat

@@ -1,4 +1,19 @@
 (component
-  (import "a" (func))
-  (export "b" (func 0))
-)
+  (type (;0;)
+    (instance
+      (type (;0;) (variant (case "foo")))
+      (export (;1;) "my-variant" (type (eq 0)))
+    )
+  )
+  (import "test:comp/indirect-dependency" (instance (;0;) (type 0)))
+  (alias export 0 "my-variant" (type (;1;)))
+  (type (;2;)
+    (instance
+      (alias outer 1 1 (type (;0;)))
+      (export (;1;) "my-variant" (type (eq 0)))
+      (type (;2;) (func (result 1)))
+      (export (;0;) "fun" (func (type 2)))
+    )
+  )
+  (import "test:comp/direct-dependency" (instance (;1;) (type 2)))
+)

crates/wac-types/src/component.rs

@@ -983,6 +983,30 @@ impl World {
 
         Ok(())
     }
+
+    /// The interfaces imported implicitly through uses.
+    pub fn implicit_imported_interfaces<'a>(
+        &'a self,
+        types: &'a Types,
+    ) -> IndexMap<&str, ItemKind> {
+        let mut interfaces = IndexMap::new();
+        for (_, import) in self.imports.iter() {
+            if let ItemKind::Instance(interface_id) = import {
+                let import = &types[*interface_id];
+                for (_, used_item) in &import.uses {
+                    let used_interface_id = used_item.interface;
+                    let used_interface = &types[used_interface_id];
+                    // The id must be set since used interfaces are always named.
+                    let used_interface_name = used_interface.id.as_ref().unwrap();
+                    interfaces.insert(
+                        used_interface_name.as_str(),
+                        ItemKind::Instance(used_interface_id),
+                    );
+                }
+            }
+        }
+        interfaces
+    }
 }
 
 /// Represents a kind of an extern item.