[wit-component] Add implements encoding support to wit-component

ricochet · ricochet · commit d460166167e8 · 2026-02-28T14:34:29.000-05:00
Update component encoding to use `name_world_key_with_item` at sites
that produce component-level extern names, so that `implements`
imports
and exports are encoded as `[implements=&lt;I&gt;]L` in the binary format.

Five call sites are changed from `name_world_key` to the
implements-aware variant: import_map key construction, component export
names, ImportedResourceDrop lookups, and both direct and indirect
InterfaceFunc lookups.
diff --git a/crates/wit-component/src/encoding.rs b/crates/wit-component/src/encoding.rs
@@ -456,6 +456,18 @@ impl<'a> EncodingState<'a> {
         }
     }
 
+    fn world_import_name(&self, key: &WorldKey) -> String {
+        let resolve = &self.info.encoder.metadata.resolve;
+        let world = &resolve.worlds[self.info.encoder.metadata.world];
+        resolve.name_world_key_with_item(key, &world.imports[key])
+    }
+
+    fn world_export_name(&self, key: &WorldKey) -> String {
+        let resolve = &self.info.encoder.metadata.resolve;
+        let world = &resolve.worlds[self.info.encoder.metadata.world];
+        resolve.name_world_key_with_item(key, &world.exports[key])
+    }
+
     fn root_import_type_encoder(
         &mut self,
         interface: Option<InterfaceId>,
@@ -731,7 +743,7 @@ impl<'a> EncodingState<'a> {
         let world = &resolve.worlds[self.info.encoder.metadata.world];
 
         for export_name in exports {
-            let export_string = resolve.name_world_key(export_name);
+            let export_string = self.world_export_name(export_name);
             match &world.exports[export_name] {
                 WorldItem::Function(func) => {
                     let ty = self
@@ -1785,7 +1797,7 @@ impl<'a> EncodingState<'a> {
                 self.materialize_wit_import(
                     shims,
                     for_module,
-                    iface.map(|_| resolve.name_world_key(key)),
+                    iface.map(|_| self.world_import_name(key)),
                     &format!("{name}_drop"),
                     key,
                     AbiVariant::GuestImport,
@@ -1955,7 +1967,7 @@ impl<'a> EncodingState<'a> {
             Import::InterfaceFunc(key, _, name, abi) => self.materialize_wit_import(
                 shims,
                 for_module,
-                Some(resolve.name_world_key(key)),
+                Some(self.world_import_name(key)),
                 name,
                 key,
                 *abi,
@@ -2849,14 +2861,15 @@ impl<'a> Shims<'a> {
                 // metadata out of this `match` to the loop below to figure that
                 // out.
                 Import::InterfaceFunc(key, _, name, abi) => {
+                    let wit_world = &resolve.worlds[world.encoder.metadata.world];
                     self.append_indirect_wit_func(
                         world,
                         for_module,
                         module,
                         field,
                         key,
                         name,
-                        Some(resolve.name_world_key(key)),
+                        Some(resolve.name_world_key_with_item(key, &wit_world.imports[key])),
                         *abi,
                     )?;
                 }
diff --git a/crates/wit-component/src/encoding/wit.rs b/crates/wit-component/src/encoding/wit.rs
@@ -73,7 +73,7 @@ pub fn encode_world(resolve: &Resolve, world_id: WorldId) -> Result<ComponentTyp
 
     // Encode the imports
     for (name, import) in world.imports.iter() {
-        let name = resolve.name_world_key(name);
+        let name = resolve.name_world_key_with_item(name, import);
         log::trace!("encoding import {name}");
         let ty = match import {
             WorldItem::Interface { id, .. } => {
@@ -98,7 +98,7 @@ pub fn encode_world(resolve: &Resolve, world_id: WorldId) -> Result<ComponentTyp
     }
     // Encode the exports
     for (name, export) in world.exports.iter() {
-        let name = resolve.name_world_key(name);
+        let name = resolve.name_world_key_with_item(name, export);
         log::trace!("encoding export {name}");
         let ty = match export {
             WorldItem::Interface { id, .. } => {
diff --git a/crates/wit-component/src/encoding/world.rs b/crates/wit-component/src/encoding/world.rs
@@ -248,7 +248,7 @@ impl<'a> ComponentWorld<'a> {
             item: &WorldItem,
             required: &Required<'_>,
         ) -> Result<()> {
-            let name = resolve.name_world_key(name);
+            let name = resolve.name_world_key_with_item(name, item);
             log::trace!("register import `{name}`");
             let import_map_key = match item {
                 WorldItem::Function(_) | WorldItem::Type { .. } => None,
@@ -314,7 +314,7 @@ impl<'a> ComponentWorld<'a> {
         // set. This means that only types not defined by referenced exports
         // will get added here.
         for (name, item) in resolve.worlds[world].exports.iter() {
-            log::trace!("add live world export `{}`", resolve.name_world_key(name));
+            log::trace!("add live world export `{}`", resolve.name_world_key_with_item(name, item));
             let id = match item {
                 WorldItem::Interface { id, .. } => id,
                 WorldItem::Function(_) | WorldItem::Type { .. } => {
diff --git a/crates/wit-component/src/printing.rs b/crates/wit-component/src/printing.rs
@@ -468,6 +468,17 @@ impl<O: Output> WitPrinter<O> {
         match name {
             WorldKey::Name(name) => {
                 match item {
+                    WorldItem::Interface {
+                        id,
+                        implements: Some(_),
+                        ..
+                    } => {
+                        // `import label: use-path;` syntax
+                        self.print_name_type(name, TypeKind::Other);
+                        self.output.str(": ");
+                        self.print_path_to_interface(resolve, *id, cur_pkg)?;
+                        self.output.semicolon();
+                    }
                     WorldItem::Interface { id, .. } => {
                         self.print_name_type(name, TypeKind::Other);
                         self.output.str(": ");
diff --git a/crates/wit-component/tests/interfaces/implements.wat b/crates/wit-component/tests/interfaces/implements.wat
@@ -0,0 +1,130 @@
+(component
+  (type (;0;)
+    (component
+      (type (;0;)
+        (instance
+          (type (;0;) (option string))
+          (type (;1;) (func (param "key" string) (result 0)))
+          (export (;0;) "get" (func (type 1)))
+          (type (;2;) (func (param "key" string) (param "value" string)))
+          (export (;1;) "set" (func (type 2)))
+        )
+      )
+      (export (;0;) "foo:foo/store" (instance (type 0)))
+    )
+  )
+  (export (;1;) "store" (type 0))
+  (type (;2;)
+    (component
+      (type (;0;)
+        (instance
+          (type (;0;) (func (param "msg" string)))
+          (export (;0;) "log" (func (type 0)))
+        )
+      )
+      (export (;0;) "foo:foo/logger" (instance (type 0)))
+    )
+  )
+  (export (;3;) "logger" (type 2))
+  (type (;4;)
+    (component
+      (type (;0;)
+        (component
+          (type (;0;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "[implements=<foo:foo/store>]primary" (instance (;0;) (type 0)))
+          (type (;1;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "[implements=<foo:foo/store>]backup" (instance (;1;) (type 1)))
+          (type (;2;)
+            (instance
+              (type (;0;) (func (param "msg" string)))
+              (export (;0;) "log" (func (type 0)))
+            )
+          )
+          (import "foo:foo/logger" (instance (;2;) (type 2)))
+        )
+      )
+      (export (;0;) "foo:foo/multi-import" (component (type 0)))
+    )
+  )
+  (export (;5;) "multi-import" (type 4))
+  (type (;6;)
+    (component
+      (type (;0;)
+        (component
+          (type (;0;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (export (;0;) "[implements=<foo:foo/store>]primary" (instance (type 0)))
+          (type (;1;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (export (;1;) "[implements=<foo:foo/store>]backup" (instance (type 1)))
+        )
+      )
+      (export (;0;) "foo:foo/multi-export" (component (type 0)))
+    )
+  )
+  (export (;7;) "multi-export" (type 6))
+  (type (;8;)
+    (component
+      (type (;0;)
+        (component
+          (type (;0;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "foo:foo/store" (instance (;0;) (type 0)))
+          (type (;1;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "[implements=<foo:foo/store>]cache" (instance (;1;) (type 1)))
+        )
+      )
+      (export (;0;) "foo:foo/mixed" (component (type 0)))
+    )
+  )
+  (export (;9;) "mixed" (type 8))
+  (@custom "package-docs" "\01{\22worlds\22:{\22multi-import\22:{\22docs\22:\22A world that imports the same interface multiple times under different\5cnplain names using the `implements` syntax.\22},\22multi-export\22:{\22docs\22:\22A world that exports the same interface multiple times.\22},\22mixed\22:{\22docs\22:\22A world with both implements imports and a normal interface import,\5cntesting that elaboration adds the dependency correctly.\22}}}")
+  (@producers
+    (processed-by "wit-component" "$CARGO_PKG_VERSION")
+  )
+)
diff --git a/crates/wit-component/tests/interfaces/implements.wit b/crates/wit-component/tests/interfaces/implements.wit
@@ -0,0 +1,31 @@
+package foo:foo;
+
+interface store {
+  get: func(key: string) -> option<string>;
+  set: func(key: string, value: string);
+}
+
+interface logger {
+  log: func(msg: string);
+}
+
+/// A world that imports the same interface multiple times under different
+/// plain names using the `implements` syntax.
+world multi-import {
+  import primary: store;
+  import backup: store;
+  import logger;
+}
+
+/// A world that exports the same interface multiple times.
+world multi-export {
+  export primary: store;
+  export backup: store;
+}
+
+/// A world with both implements imports and a normal interface import,
+/// testing that elaboration adds the dependency correctly.
+world mixed {
+  import store;
+  import cache: store;
+}
diff --git a/crates/wit-component/tests/interfaces/implements.wit.print b/crates/wit-component/tests/interfaces/implements.wit.print
@@ -0,0 +1,30 @@
+package foo:foo;
+
+interface store {
+  get: func(key: string) -> option<string>;
+
+  set: func(key: string, value: string);
+}
+
+interface logger {
+  log: func(msg: string);
+}
+
+/// A world that imports the same interface multiple times under different
+/// plain names using the `implements` syntax.
+world multi-import {
+  import primary: store;
+  import backup: store;
+  import logger;
+}
+/// A world that exports the same interface multiple times.
+world multi-export {
+  export primary: store;
+  export backup: store;
+}
+/// A world with both implements imports and a normal interface import,
+/// testing that elaboration adds the dependency correctly.
+world mixed {
+  import store;
+  import cache: store;
+}
