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

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=<I>]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.

Author: ricochet

crates/wit-component/src/encoding.rs

@@ -401,6 +401,7 @@ pub struct EncodingState<'a> {
 
     /// Imported instances and what index they were imported as.
     imported_instances: IndexMap<InterfaceId, u32>,
+    imported_instances_by_name: HashMap<String, u32>,
     imported_funcs: IndexMap<String, u32>,
     exported_instances: IndexMap<InterfaceId, u32>,
 
@@ -456,6 +457,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>,
@@ -492,7 +505,8 @@ impl<'a> EncodingState<'a> {
         for (name, info) in self.info.import_map.iter() {
             match name {
                 Some(name) => {
-                    self.encode_interface_import(name_map.get(name).unwrap_or(name), info)?
+                    let import_name = name_map.get(name).unwrap_or(name);
+                    self.encode_interface_import(import_name, name, info)?
                 }
                 None => has_funcs = true,
             }
@@ -517,7 +531,12 @@ impl<'a> EncodingState<'a> {
         Ok(())
     }
 
-    fn encode_interface_import(&mut self, name: &str, info: &ImportedInterface) -> Result<()> {
+    fn encode_interface_import(
+        &mut self,
+        name: &str,
+        import_key: &str,
+        info: &ImportedInterface,
+    ) -> Result<()> {
         let resolve = &self.info.encoder.metadata.resolve;
         let interface_id = info.interface.as_ref().unwrap();
         let interface_id = *interface_id;
@@ -566,8 +585,11 @@ impl<'a> EncodingState<'a> {
         let instance_idx = self
             .component
             .import(name, ComponentTypeRef::Instance(instance_type_idx));
-        let prev = self.imported_instances.insert(interface_id, instance_idx);
-        assert!(prev.is_none());
+        self.imported_instances
+            .entry(interface_id)
+            .or_insert(instance_idx);
+        self.imported_instances_by_name
+            .insert(import_key.to_string(), instance_idx);
         Ok(())
     }
 
@@ -704,9 +726,9 @@ impl<'a> EncodingState<'a> {
                     let prev = world_func_core_names.insert(name, core_name);
                     assert!(prev.is_none());
                 }
-                Export::InterfaceFunc(_, id, name, _) => {
+                Export::InterfaceFunc(key, _id, name, _) => {
                     let prev = interface_func_core_names
-                        .entry(id)
+                        .entry(key)
                         .or_insert(IndexMap::new())
                         .insert(name.as_str(), core_name);
                     assert!(prev.is_none());
@@ -731,7 +753,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
@@ -743,7 +765,7 @@ impl<'a> EncodingState<'a> {
                         .export(&export_string, ComponentExportKind::Func, idx, None);
                 }
                 WorldItem::Interface { id, .. } => {
-                    let core_names = interface_func_core_names.get(id);
+                    let core_names = interface_func_core_names.get(export_name);
                     self.encode_interface_export(
                         &export_string,
                         module,
@@ -966,8 +988,7 @@ impl<'a> EncodingState<'a> {
             instance_index,
             None,
         );
-        let prev = self.exported_instances.insert(export, idx);
-        assert!(prev.is_none());
+        self.exported_instances.entry(export).or_insert(idx);
 
         // After everything is all said and done remove all the type information
         // about type exports of this interface. Any entries in the map
@@ -1292,11 +1313,12 @@ impl<'a> EncodingState<'a> {
                     realloc,
                     encoding,
                 } => {
-                    let interface = &self.info.import_map[interface];
-                    let ((name, _), _) = interface.lowerings.get_index(*index).unwrap();
-                    let func_index = match &interface.interface {
-                        Some(interface_id) => {
-                            let instance_index = self.imported_instances[interface_id];
+                    let import = &self.info.import_map[interface];
+                    let ((name, _), _) = import.lowerings.get_index(*index).unwrap();
+                    let func_index = match interface {
+                        Some(iface_key) => {
+                            let instance_index =
+                                self.imported_instances_by_name[iface_key.as_str()];
                             self.component.alias_export(
                                 instance_index,
                                 name,
@@ -1309,7 +1331,7 @@ impl<'a> EncodingState<'a> {
                     let realloc = self
                         .info
                         .exports_for(*realloc)
-                        .import_realloc_for(interface.interface, name)
+                        .import_realloc_for(import.interface, name)
                         .map(|name| {
                             let instance = self.instance_for(*realloc);
                             self.core_alias_export(
@@ -1785,7 +1807,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 +1977,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,
@@ -2072,9 +2094,9 @@ impl<'a> EncodingState<'a> {
             // All direct lowerings can be `canon lower`'d here immediately
             // and passed as arguments.
             Lowering::Direct => {
-                let func_index = match &import.interface {
-                    Some(interface) => {
-                        let instance_index = self.imported_instances[interface];
+                let func_index = match &interface_key {
+                    Some(iface_key) => {
+                        let instance_index = self.imported_instances_by_name[iface_key.as_str()];
                         self.component
                             .alias_export(instance_index, name, ComponentExportKind::Func)
                     }
@@ -2849,14 +2871,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,
                     )?;
                 }
@@ -3343,6 +3366,7 @@ impl ComponentEncoder {
             import_type_encoding_maps: Default::default(),
             export_type_encoding_maps: Default::default(),
             imported_instances: Default::default(),
+            imported_instances_by_name: Default::default(),
             imported_funcs: Default::default(),
             exported_instances: Default::default(),
             aliased_core_items: Default::default(),

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, .. } => {

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,10 @@ 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 { .. } => {
@@ -453,6 +456,10 @@ impl<'a> ComponentWorld<'a> {
                 WorldItem::Interface { id, .. } => *id,
                 WorldItem::Type { .. } => unreachable!(),
             };
+            // Skip already-processed interfaces (implements duplicates).
+            if self.exports_used.contains_key(&id) {
+                continue;
+            }
             let mut set = HashSet::new();
 
             for other in resolve.interface_direct_deps(id) {

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(": ");

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")
+  )
+)