Add implements clause support to wac

Support the component model's implements name form, which allows
importing/exporting the same interface multiple times under different
plain-name labels (e.g., primary/backup stores).

Author: ricochet

Cargo.lock

@@ -63,13 +63,13 @@ wac-parser = { path = "crates/wac-parser", version = "0.10.1", default-features
 wac-resolver = { path = "crates/wac-resolver", version = "0.10.1", default-features = false }
 wac-graph = { path = "crates/wac-graph", version = "0.10.1" }
 wac-types = { path = "crates/wac-types", version = "0.10.1" }
-wit-parser = "0.247.0"
-wasmparser = "0.247.0"
-wit-component = "0.247.0"
-wasm-encoder = "0.247.0"
-wasmprinter = "0.247.0"
-wasm-metadata = "0.247.0"
-wat = "1.245.1"
+wit-parser = "0.252.0"
+wasmparser = "0.252.0"
+wit-component = "0.252.0"
+wasm-encoder = "0.252.0"
+wasmprinter = "0.252.0"
+wasm-metadata = "0.252.0"
+wat = "1.252.0"
 anyhow = "1.0.81"
 clap = { version = "4.5.4", features = ["derive"] }
 semver = { version = "1.0.22", features = ["serde"] }

Cargo.toml

@@ -1,18 +1,37 @@
 use crate::PackageId;
 use indexmap::IndexMap;
 use petgraph::graph::NodeIndex;
+use std::borrow::Cow;
 use std::collections::HashMap;
 use wac_types::{
     CoreExtern, DefinedType, DefinedTypeId, Enum, Flags, FuncTypeId, InterfaceId, ItemKind,
     ModuleTypeId, PrimitiveType, Record, ResourceId, Type, Types, UsedType, ValueType, Variant,
     WorldId,
 };
 use wasm_encoder::{
-    Alias, ComponentBuilder, ComponentCoreTypeEncoder, ComponentExportKind,
+    Alias, ComponentBuilder, ComponentCoreTypeEncoder, ComponentExportKind, ComponentExternName,
     ComponentOuterAliasKind, ComponentType, ComponentTypeEncoder, ComponentTypeRef,
     ComponentValType, EntityType, GlobalType, InstanceType, MemoryType, ModuleType, TableType,
     TagKind, TagType, TypeBounds,
 };
+use wasmparser::names::{ComponentName, ComponentNameKind};
+
+/// Returns the `(implements "I")` interface id for an instance import or export,
+/// if its extern name is a plain-name label rather than an interface name.
+///
+/// A component model `(implements "I")` import/export is an instance whose
+/// extern name is a plain-name label (e.g. `primary`) rather than an interface
+/// name, while the interface it implements has its own id (e.g. `foo:bar/iface`).
+/// A regular interface import/export instead uses the interface name itself as
+/// its extern name.
+pub(crate) fn implements_of<'a>(types: &'a Types, name: &str, id: InterfaceId) -> Option<&'a str> {
+    types[id].id.as_deref().filter(|_| {
+        matches!(
+            ComponentName::new(name, 0).as_ref().map(|n| n.kind()),
+            Ok(ComponentNameKind::Label(_))
+        )
+    })
+}
 
 /// A type used to abstract the API differences between a component builder,
 /// component type, and instance type from `wasm-encoder`.
@@ -65,7 +84,8 @@ impl Encodable {
         }
     }
 
-    fn import_type(&mut self, name: &str, ty: ComponentTypeRef) {
+    fn import_type<'a>(&mut self, name: impl Into<ComponentExternName<'a>>, ty: ComponentTypeRef) {
+        let name = name.into();
         match self {
             Encodable::Component(t) => {
                 t.import(name, ty);
@@ -730,13 +750,22 @@ impl<'a> TypeEncoder<'a> {
             }
             ItemKind::Instance(id) => {
                 let import_index = state.current.encodable.instance_count();
+                let implements = implements_of(self.0, name, id);
+                let extern_name = ComponentExternName {
+                    name: Cow::Borrowed(name),
+                    implements: implements.map(Cow::Borrowed),
+                };
                 state
                     .current
                     .encodable
-                    .import_type(name, ComponentTypeRef::Instance(index));
-                if let Some(iid) = &self.0[id].id {
-                    log::debug!("instance index {import_index} ({iid}) is available for aliasing");
-                    state.current.instances.insert(iid.clone(), import_index);
+                    .import_type(extern_name, ComponentTypeRef::Instance(index));
+                if implements.is_none() {
+                    if let Some(iid) = &self.0[id].id {
+                        log::debug!(
+                            "instance index {import_index} ({iid}) is available for aliasing"
+                        );
+                        state.current.instances.insert(iid.clone(), import_index);
+                    }
                 }
             }
             _ => panic!("expected only types, functions, and instance types"),
@@ -827,9 +856,19 @@ impl<'a> TypeEncoder<'a> {
 
         let ty = kind.ty();
         let index = self.ty(state, ty, Some(name));
+        // Preserve the `(implements "I")` directive when re-encoding an
+        // instance export that uses a plain-name label.
+        let implements = match kind {
+            ItemKind::Instance(id) => implements_of(self.0, name, id),
+            _ => None,
+        };
+        let extern_name = ComponentExternName {
+            name: Cow::Borrowed(name),
+            implements: implements.map(Cow::Borrowed),
+        };
         let index = Self::export_type(
             state,
-            name,
+            extern_name,
             match kind {
                 ItemKind::Type(_) => ComponentTypeRef::Type(TypeBounds::Eq(index)),
                 ItemKind::Func(_) => ComponentTypeRef::Func(index),
@@ -880,7 +919,12 @@ impl<'a> TypeEncoder<'a> {
         index
     }
 
-    fn export_type(state: &mut State, name: &str, ty: ComponentTypeRef) -> u32 {
+    fn export_type<'b>(
+        state: &mut State,
+        name: impl Into<ComponentExternName<'b>>,
+        ty: ComponentTypeRef,
+    ) -> u32 {
+        let name = name.into();
         match &mut state.current.encodable {
             Encodable::Component(t) => {
                 let index = t.type_count();