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,36 @@
 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, if the
+/// import name is a plain-name label rather than an interface name.
+///
+/// A component model `(implements "I")` import 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 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 +83,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 +749,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"),