Allow adapters to import multiple interfaces (#398)

This commit lifts the restriction that an adapter module as part of
`wit-component` can only import a single interface. That restriction was
a temporary artifact of the initial implementation due to the fact that
at the time there was no convenient way to communicate about multiple
imported interfaces. With the `ComponentInterfaces` encoding of a
"world" now, though, the `wit-component` CLI is updated to require that
the incoming adapter module has a `component-type*` custom section
describing the world that it's importing.

Author: alexcrichton

crates/wit-component/src/cli.rs

@@ -1,10 +1,6 @@
 //! The WebAssembly component tool command line interface.
 
-use crate::extract::{extract_module_interfaces, ModuleInterfaces};
-use crate::{
-    decode_component_interfaces, ComponentEncoder, ComponentInterfaces, InterfacePrinter,
-    StringEncoding,
-};
+use crate::{decode_component_interfaces, ComponentEncoder, InterfacePrinter, StringEncoding};
 use anyhow::{anyhow, bail, Context, Result};
 use clap::Parser;
 use std::path::{Path, PathBuf};
@@ -48,38 +44,10 @@ fn parse_interface(name: Option<String>, path: &Path) -> Result<Interface> {
     Ok(interface)
 }
 
-fn parse_adapter(s: &str) -> Result<(String, Vec<u8>, Interface)> {
-    let mut parts = s.splitn(2, ':');
-    let maybe_named_module = parts.next().unwrap();
-    let (name, path) = parse_optionally_name_file(maybe_named_module);
+fn parse_adapter(s: &str) -> Result<(String, Vec<u8>)> {
+    let (name, path) = parse_optionally_name_file(s);
     let wasm = wat::parse_file(path)?;
-
-    match parts.next() {
-        Some(maybe_named_interface) => {
-            let interface = parse_named_interface(maybe_named_interface)?;
-            Ok((name.to_string(), wasm, interface))
-        }
-        None => {
-            let ModuleInterfaces {
-                wasm,
-                interfaces:
-                    ComponentInterfaces {
-                        imports,
-                        exports,
-                        default,
-                    },
-            } = extract_module_interfaces(&wasm)?;
-            if !exports.is_empty() || default.is_some() {
-                bail!("adapter modules cannot have an exported interface");
-            }
-            let import = match imports.len() {
-                0 => Interface::default(),
-                1 => imports.into_iter().next().unwrap().1,
-                _ => bail!("adapter modules can only import one interface at this time"),
-            };
-            Ok((name.to_string(), wasm, import))
-        }
-    }
+    Ok((name.to_string(), wasm))
 }
 
 /// WebAssembly component encoder.
@@ -107,8 +75,8 @@ pub struct WitComponentApp {
     /// The second part of this argument, optionally specified, is the interface
     /// that this adapter module imports. If not specified then the interface
     /// imported is inferred from the adapter module itself.
-    #[clap(long = "adapt", value_name = "[NAME=]MODULE[:[NAME=]INTERFACE]", value_parser = parse_adapter)]
-    pub adapters: Vec<(String, Vec<u8>, Interface)>,
+    #[clap(long = "adapt", value_name = "[NAME=]MODULE", value_parser = parse_adapter)]
+    pub adapters: Vec<(String, Vec<u8>)>,
 
     /// The path of the output WebAssembly component.
     #[clap(long, short = 'o', value_name = "OUTPUT")]
@@ -157,8 +125,8 @@ impl WitComponentApp {
             .exports(self.exports)?
             .validate(!self.skip_validation);
 
-        for (name, wasm, interface) in self.adapters.iter() {
-            encoder = encoder.adapter(name, wasm, interface);
+        for (name, wasm) in self.adapters.iter() {
+            encoder = encoder.adapter(name, wasm)?;
         }
 
         if let Some(interface) = self.interface {

crates/wit-component/src/encoding.rs

@@ -1386,7 +1386,7 @@ impl<'a> EncodingState<'a> {
         // interface imported into the shim module itself.
         for (adapter, funcs) in info.adapters_required.iter() {
             let info = &imports.adapters[adapter];
-            if let Some(name) = info.required_import {
+            for (name, _) in info.required_imports.iter() {
                 let import = &imports.map[name];
                 ret.append_indirect(
                     name,
@@ -1654,7 +1654,7 @@ impl<'a> EncodingState<'a> {
             // different from the imported interface. That's true enough for now
             // since it's `env::memory`.
             if let Some((module, name)) = &info.needs_memory {
-                if let Some(import_name) = info.required_import {
+                for (import_name, _) in info.required_imports.iter() {
                     assert!(module != import_name);
                 }
                 assert!(module != name);
@@ -1666,7 +1666,7 @@ impl<'a> EncodingState<'a> {
                 )]);
                 args.push((module.as_str(), ModuleArg::Instance(instance)));
             }
-            if let Some(import_name) = info.required_import {
+            for (import_name, _) in info.required_imports.iter() {
                 let instance = self.import_instance_to_lowered_core_instance(
                     CustomModule::Adapter(name),
                     import_name,
@@ -2094,7 +2094,13 @@ pub struct ComponentEncoder {
     exports: IndexMap<String, Interface>,
     validate: bool,
     types_only: bool,
-    adapters: IndexMap<String, (Vec<u8>, Interface)>,
+
+    // This is a map from the name of the adapter to a pair of:
+    //
+    // * the wasm of the adapter itself, with `component-type` sections stripped
+    // * the map of imported interfaces into the adapter, keyed by name of the
+    //   interface
+    adapters: IndexMap<String, (Vec<u8>, IndexMap<String, Interface>)>,
 }
 
 impl ComponentEncoder {
@@ -2181,10 +2187,21 @@ impl ComponentEncoder {
     /// wasm module specified by `bytes` imports. The `bytes` will then import
     /// `interface` and export functions to get imported from the module `name`
     /// in the core wasm that's being wrapped.
-    pub fn adapter(mut self, name: &str, bytes: &[u8], interface: &Interface) -> Self {
-        self.adapters
-            .insert(name.to_string(), (bytes.to_vec(), interface.clone()));
-        self
+    pub fn adapter(mut self, name: &str, bytes: &[u8]) -> Result<Self> {
+        let ModuleInterfaces {
+            wasm,
+            interfaces:
+                ComponentInterfaces {
+                    imports,
+                    exports,
+                    default,
+                },
+        } = extract_module_interfaces(bytes)?;
+        if !exports.is_empty() || default.is_some() {
+            bail!("adapters cannot have any exported interfaces");
+        }
+        self.adapters.insert(name.to_string(), (wasm, imports));
+        Ok(self)
     }
 
     /// This is a convenience method for [`ComponentEncoder::adapter`] for
@@ -2194,31 +2211,13 @@ impl ComponentEncoder {
     /// embedded information about its imported interfaces. Additionally the
     /// name of the adapter is inferred from the file name itself as the file
     /// stem.
-    pub fn adapter_file(mut self, path: &Path) -> Result<Self> {
+    pub fn adapter_file(self, path: &Path) -> Result<Self> {
         let name = path
             .file_stem()
             .and_then(|s| s.to_str())
             .ok_or_else(|| anyhow!("input filename was not valid utf-8"))?;
         let wasm = wat::parse_file(path)?;
-        let ModuleInterfaces {
-            wasm,
-            interfaces:
-                ComponentInterfaces {
-                    imports,
-                    exports,
-                    default,
-                },
-        } = extract_module_interfaces(&wasm)?;
-        if !exports.is_empty() || default.is_some() {
-            bail!("adapter modules cannot have an exported interface");
-        }
-        let import = match imports.len() {
-            0 => Interface::default(),
-            1 => imports.into_iter().next().unwrap().1,
-            _ => bail!("adapter modules can only import one interface at this time"),
-        };
-        self.adapters.insert(name.to_string(), (wasm, import));
-        Ok(self)
+        self.adapter(name, &wasm)
     }
 
     /// Indicates whether this encoder is only encoding types and does not
@@ -2308,17 +2307,16 @@ impl ComponentEncoder {
             // provided to this encoder, gc it to an appropriate size, and then
             // register its metadata in our data structures.
             for (name, required) in info.adapters_required.iter() {
-                let (wasm, interface) = &self.adapters[*name];
+                let (wasm, adapter_imports) = &self.adapters[*name];
                 let wasm = crate::gc::run(wasm, required)
                     .context("failed to reduce input adapter module to its minimal size")?;
-                let info = validate_adapter_module(&wasm, interface, required)
+                let info = validate_adapter_module(&wasm, adapter_imports, required)
                     .context("failed to validate the imports of the minimized adapter module")?;
                 state.encode_core_adapter_module(name, &wasm);
-                types.encode_instance_import(
-                    interface,
-                    Some(&info.required_funcs),
-                    &mut imports,
-                )?;
+                for (name, required) in info.required_imports.iter() {
+                    let interface = &adapter_imports[*name];
+                    types.encode_instance_import(interface, Some(required), &mut imports)?;
+                }
                 imports.adapters.insert(name, info);
             }
 

crates/wit-component/src/validation.rs

@@ -189,17 +189,10 @@ pub fn validate_module<'a>(
 /// This is created by the `validate_adapter_module` function.
 #[derive(Default, Debug)]
 pub struct ValidatedAdapter<'a> {
-    /// If specified then this is the name of the required interface imported
-    /// into the adapter module.
-    ///
-    /// At this time only one interface import is supported. If this is `None`
-    /// then the adapter module didn't import any component model functions to
-    /// implement the required functionality.
-    pub required_import: Option<&'a str>,
-
-    /// This is the set of required functions imported from `required_import`,
-    /// if `required_import` is specified.
-    pub required_funcs: IndexSet<&'a str>,
+    /// If specified this is the list of required imports from the original set
+    /// of possible imports along with the set of functions required from each
+    /// imported interface.
+    pub required_imports: IndexMap<&'a str, IndexSet<&'a str>>,
 
     /// This is the module and field name of the memory import, if one is
     /// specified.
@@ -227,7 +220,7 @@ pub struct ValidatedAdapter<'a> {
 /// didn't accidentally break the wasm module.
 pub fn validate_adapter_module<'a>(
     bytes: &[u8],
-    interface: &'a Interface,
+    imports: &'a IndexMap<String, Interface>,
     required: &IndexMap<&str, FuncType>,
 ) -> Result<ValidatedAdapter<'a>> {
     let mut validator = Validator::new();
@@ -308,21 +301,14 @@ pub fn validate_adapter_module<'a>(
     }
 
     let types = types.unwrap();
-    let mut import_funcs = import_funcs.iter();
-    if let Some((name, funcs)) = import_funcs.next() {
-        if *name != interface.name {
-            bail!(
-                "adapter module imports from `{name}` which does not match \
-                 its interface `{}`",
-                interface.name
-            );
-        }
-        ret.required_funcs = validate_imported_interface(interface, name, funcs, &types)?;
-        ret.required_import = Some(interface.name.as_str());
-
-        if let Some((name, _)) = import_funcs.next() {
-            bail!("adapter module cannot import from a second interface `{name}`")
-        }
+    for (name, funcs) in import_funcs {
+        let interface = imports
+            .get(name)
+            .ok_or_else(|| anyhow!("adapter module imports unknown module `{name}`"))?;
+        let required_funcs = validate_imported_interface(interface, name, &funcs, &types)?;
+        assert_eq!(interface.name, name);
+        ret.required_imports
+            .insert(interface.name.as_str(), required_funcs);
     }
 
     for (name, ty) in required {

crates/wit-component/tests/components.rs

@@ -1,6 +1,7 @@
 use anyhow::{bail, Context, Result};
 use pretty_assertions::assert_eq;
 use std::{fs, path::Path};
+use wasm_encoder::{Encode, Section};
 use wit_component::ComponentEncoder;
 use wit_parser::Interface;
 
@@ -27,28 +28,34 @@ fn read_interfaces(dir: &Path, pattern: &str) -> Result<Vec<Interface>> {
         .collect::<Result<_>>()
 }
 
-fn read_adapters(dir: &Path) -> Result<Vec<(String, Vec<u8>, Interface)>> {
+fn read_adapters(dir: &Path) -> Result<Vec<(String, Vec<u8>, Vec<Interface>)>> {
     glob::glob(dir.join("adapt-*.wat").to_str().unwrap())?
         .map(|p| {
             let p = p?;
             let adapter =
                 wat::parse_file(&p).with_context(|| format!("expected file `{}`", p.display()))?;
             let stem = p.file_stem().unwrap().to_str().unwrap();
             let glob = format!("{stem}-import-*.wit");
-            let wit = match glob::glob(dir.join(&glob).to_str().unwrap())?.next() {
-                Some(path) => path?,
-                None => bail!("failed to find `{glob}` match"),
-            };
-            let mut i = read_interface(&wit)?;
-            i.name = wit
-                .file_stem()
-                .unwrap()
-                .to_str()
-                .unwrap()
-                .trim_start_matches(stem)
-                .trim_start_matches("-import-")
-                .to_string();
-            Ok((stem.trim_start_matches("adapt-").to_string(), adapter, i))
+            let imports = glob::glob(dir.join(&glob).to_str().unwrap())?
+                .map(|path| {
+                    let path = path?;
+                    let mut i = read_interface(&path)?;
+                    i.name = path
+                        .file_stem()
+                        .unwrap()
+                        .to_str()
+                        .unwrap()
+                        .trim_start_matches(stem)
+                        .trim_start_matches("-import-")
+                        .to_string();
+                    Ok(i)
+                })
+                .collect::<Result<Vec<_>>>()?;
+            Ok((
+                stem.trim_start_matches("adapt-").to_string(),
+                adapter,
+                imports,
+            ))
         })
         .collect::<Result<_>>()
 }
@@ -136,8 +143,6 @@ fn component_encoding_via_flags() -> Result<()> {
 /// needing the wit files passed in as well.
 #[test]
 fn component_encoding_via_custom_sections() -> Result<()> {
-    use wasm_encoder::{Encode, Section};
-
     for entry in fs::read_dir("tests/components")? {
         let path = entry?.path();
         if !path.is_dir() {
@@ -184,9 +189,22 @@ fn component_encoding_via_custom_sections() -> Result<()> {
 }
 
 fn add_adapters(mut encoder: ComponentEncoder, path: &Path) -> Result<ComponentEncoder> {
-    let adapters = read_adapters(path)?;
-    for (name, wasm, interface) in adapters.iter() {
-        encoder = encoder.adapter(name, wasm, interface);
+    for (name, mut wasm, imports) in read_adapters(path)? {
+        // Create a `component-type` custom section by slurping up `imports` as
+        // a "world" and encoding it.
+        let mut types_encoder = ComponentEncoder::default().types_only(true).validate(true);
+        types_encoder = types_encoder.imports(imports)?;
+        let contents = types_encoder.encode()?;
+        let section = wasm_encoder::CustomSection {
+            name: "component-type",
+            data: &contents,
+        };
+        wasm.push(section.id());
+        section.encode(&mut wasm);
+
+        // Then register our new wasm blob which has the necessary custom
+        // section.
+        encoder = encoder.adapter(&name, &wasm)?;
     }
     Ok(encoder)
 }

crates/wit-component/tests/components/adapt-multiple/adapt-foo-import-other1.wit

@@ -0,0 +1 @@
+foo: func()

crates/wit-component/tests/components/adapt-multiple/adapt-foo-import-other2.wit

@@ -0,0 +1 @@
+bar: func()

crates/wit-component/tests/components/adapt-multiple/adapt-foo.wat

@@ -0,0 +1,10 @@
+;; this is a polyfill module that translates from wasi-preview1 to a different
+;; interface
+
+(module
+  (import "other1" "foo" (func $foo))
+  (import "other2" "bar" (func $bar))
+
+  (func (export "foo") call $foo)
+  (func (export "bar") call $bar)
+)