fix: alias instance-exported types reached by id in aggregated imports

Top-level aggregated imports carry no `uses` map, so a type referenced by
id (e.g. an imported instance's export used in a record field) was
re-encoded as an invalid local definition. `value_type` now aliases it
from the imported instance, and imports are encoded instances-first.

Author: salmans

crates/wac-graph/src/encoding.rs

@@ -190,6 +190,28 @@ impl<'a> TypeEncoder<'a> {
         Self(types)
     }
 
+    // Aliases a value type from an imported instance that exports it, rather
+    // than re-encoding it locally; a local definition is invalid as an
+    // import bound.
+    fn aliased_instance_export(&self, state: &mut State, ty: ValueType) -> Option<u32> {
+        let ty = Type::Value(ty);
+        let (instance, name) = self.0.interfaces().find_map(|interface| {
+            let iid = interface.id.as_ref()?;
+            let instance = *state.current.instances.get(iid)?;
+            interface.exports.iter().find_map(|(name, kind)| {
+                matches!(kind, ItemKind::Type(t) if *t == ty).then(|| (instance, name.clone()))
+            })
+        })?;
+        let index = state.current.encodable.type_count();
+        state.current.encodable.alias(Alias::InstanceExport {
+            instance,
+            kind: ComponentExportKind::Type,
+            name: &name,
+        });
+        state.current.type_indexes.insert(ty, index);
+        Some(index)
+    }
+
     pub fn ty(&self, state: &mut State, ty: Type, name: Option<&str>) -> u32 {
         if let Some(index) = state.current.type_indexes.get(&ty) {
             return *index;
@@ -533,6 +555,10 @@ impl<'a> TypeEncoder<'a> {
             return ComponentValType::Type(*index);
         }
 
+        if let Some(index) = self.aliased_instance_export(state, ty) {
+            return ComponentValType::Type(index);
+        }
+
         let index = match ty {
             ValueType::Primitive(ty) => return ComponentValType::Primitive(ty.into()),
             ValueType::Borrow(id) => self.borrow(state, id),

crates/wac-graph/src/graph.rs

@@ -1544,8 +1544,12 @@ impl<'a> CompositionGraphEncoder<'a> {
 
         let mut encoded = HashMap::new();
 
-        // Next encode the imports
-        for (name, kind) in aggregator.imports() {
+        // Instances first, so a later type import can alias a type from an
+        // instance export instead of re-encoding it as a local definition.
+        let (instances, rest): (Vec<_>, Vec<_>) = aggregator
+            .imports()
+            .partition(|(_, kind)| matches!(kind, ItemKind::Instance(_)));
+        for (name, kind) in instances.into_iter().chain(rest) {
             log::debug!("import `{name}` is being imported");
             let index = self.import(state, name, aggregator.types(), kind);
             encoded.insert(name, (kind.into(), index));

crates/wac-graph/tests/graphs/implicit-resource-import/encoded.wat

@@ -6,19 +6,18 @@
   )
   (import "foo:dependency/types" (instance (;0;) (type 0)))
   (alias export 0 "x" (type (;1;)))
-  (import "x" (type (;2;) (eq 1)))
-  (alias export 0 "x" (type (;3;)))
-  (type (;4;)
+  (type (;2;)
     (instance
-      (alias outer 1 3 (type (;0;)))
+      (alias outer 1 1 (type (;0;)))
       (export (;1;) "x" (type (eq 0)))
       (type (;2;) (own 1))
       (type (;3;) (func (result 2)))
       (export (;0;) "my-func" (func (type 3)))
     )
   )
-  (import "foo:test-import/my-interface" (instance (;1;) (type 4)))
-  (type (;5;)
+  (import "foo:test-import/my-interface" (instance (;1;) (type 2)))
+  (import "x" (type (;3;) (eq 1)))
+  (type (;4;)
     (component
       (type (;0;)
         (instance
@@ -28,30 +27,30 @@
       (export (;0;) "foo:dependency/types" (instance (type 0)))
     )
   )
-  (import "unlocked-dep=<test:bar>" (component (;0;) (type 5)))
+  (import "unlocked-dep=<test:bar>" (component (;0;) (type 4)))
   (instance (;2;) (instantiate 0))
   (alias export 1 "my-func" (func (;0;)))
   (alias export 2 "foo:dependency/types" (instance (;3;)))
-  (type (;6;)
+  (type (;5;)
     (component
       (type (;0;)
         (instance
           (export (;0;) "x" (type (sub resource)))
         )
       )
       (import "foo:dependency/types" (instance (;0;) (type 0)))
-      (alias outer 1 3 (type (;1;)))
+      (alias outer 1 1 (type (;1;)))
       (import "x" (type (;2;) (eq 1)))
       (type (;3;) (own 2))
       (type (;4;) (func (result 3)))
       (import "my-func" (func (;0;) (type 4)))
     )
   )
-  (import "unlocked-dep=<test:baz>" (component (;1;) (type 6)))
+  (import "unlocked-dep=<test:baz>" (component (;1;) (type 5)))
   (instance (;4;) (instantiate 1
       (with "foo:dependency/types" (instance 3))
       (with "my-func" (func 0))
-      (with "x" (type 2))
+      (with "x" (type 3))
     )
   )
 )

crates/wac-graph/tests/graphs/use-type-by-id-import/encoded.wat

@@ -0,0 +1,36 @@
+(component
+  (type (;0;)
+    (instance
+      (type (;0;) (record (field "x" s32)))
+      (export (;1;) "point" (type (eq 0)))
+    )
+  )
+  (import "test:lib/shapes" (instance (;0;) (type 0)))
+  (alias export 0 "point" (type (;1;)))
+  (type (;2;) (record (field "origin" 1)))
+  (import "region" (type (;3;) (eq 2)))
+  (type (;4;)
+    (component
+      (type (;0;)
+        (instance
+          (type (;0;) (record (field "x" s32)))
+          (export (;1;) "point" (type (eq 0)))
+        )
+      )
+      (import "test:lib/shapes" (instance (;0;) (type 0)))
+      (alias export 0 "point" (type (;1;)))
+      (type (;2;) (record (field "origin" 1)))
+      (import "region" (type (;3;) (eq 2)))
+      (type (;4;) (func (result s32)))
+      (export (;0;) "run" (func (type 4)))
+    )
+  )
+  (import "unlocked-dep=<test:m>" (component (;0;) (type 4)))
+  (instance (;1;) (instantiate 0
+      (with "test:lib/shapes" (instance 0))
+      (with "region" (type 3))
+    )
+  )
+  (alias export 1 "run" (func (;0;)))
+  (export (;1;) "run" (func 0))
+)

crates/wac-graph/tests/graphs/use-type-by-id-import/graph.json

@@ -0,0 +1,12 @@
+{
+    "packages": [
+        { "name": "test:m", "path": "m.wat" }
+    ],
+    "nodes": [
+        { "type": "instantiation", "package": 0 },
+        { "type": "alias", "source": 0, "export": "run" }
+    ],
+    "exports": [
+        { "node": 1, "name": "run" }
+    ]
+}

crates/wac-graph/tests/graphs/use-type-by-id-import/m.wat

@@ -0,0 +1,28 @@
+(component
+  ;; Origin interface `shapes`, exporting `point`.
+  (type (;0;)
+    (instance
+      (type (;0;) (record (field "x" s32)))
+      (export (;1;) "point" (type (eq 0)))
+    )
+  )
+  (import "test:lib/shapes" (instance (;0;) (type 0)))
+  (alias export 0 "point" (type (;1;)))
+
+  ;; A record whose field references `point` from `shapes` by id. wit-component
+  ;; produces this shape for a world that imports `shapes` and `use`s a record
+  ;; built on `point`.
+  (type (;2;) (record (field "origin" 1)))
+  (import "region" (type (;3;) (eq 2)))
+
+  (core module (;0;)
+    (type (;0;) (func (result i32)))
+    (func (;0;) (type 0) (result i32) i32.const 7)
+    (export "run" (func 0))
+  )
+  (core instance (;0;) (instantiate 0))
+  (alias core export 0 "run" (core func (;0;)))
+  (type (;4;) (func (result s32)))
+  (func (;0;) (type 4) (canon lift (core func 0)))
+  (export "run" (func 0))
+)

crates/wac-parser/tests/encoding/instantiation.wac.result

@@ -1,27 +1,27 @@
 (component
-  (type (;0;) (func))
-  (import "baz" (func (;0;) (type 0)))
-  (type (;1;)
+  (type (;0;)
     (instance
       (type (;0;) (func))
       (export (;0;) "foo" (func (type 0)))
     )
   )
-  (import "foo" (instance (;0;) (type 1)))
-  (type (;2;)
+  (import "foo" (instance (;0;) (type 0)))
+  (type (;1;)
     (instance
       (type (;0;) (func))
       (export (;0;) "foo" (func (type 0)))
     )
   )
-  (import "i" (instance $i (;1;) (type 2)))
-  (type (;3;)
+  (import "i" (instance $i (;1;) (type 1)))
+  (type (;2;)
     (instance
       (type (;0;) (func))
       (export (;0;) "baz" (func (type 0)))
     )
   )
-  (import "i2" (instance $i2 (;2;) (type 3)))
+  (import "i2" (instance $i2 (;2;) (type 2)))
+  (type (;3;) (func))
+  (import "baz" (func (;0;) (type 3)))
   (type (;4;) (func))
   (import "f" (func $f (;1;) (type 4)))
   (type (;5;)