support combining SDKs with multiple WIT worlds

This adds two new features:

- Multiple `--world` options are accepted, in which case the worlds will be
  merged into a single world for building, testing, or bindings generation.

- Zero or more `--wit-module` options are accepted, which allow the user to
  specify a WIT path by way of a Go module whose source code contains a
  subdirectory called "wit".

In combination, these options make it easier to use multiple SDKs or other
libraries which contain `wit-bindgen-go`-generated code.

For example say module `example.com/foo` contains code that targets the
`com:example/foo` world, while `example.com/bar` contains code that targets the
`com:example/bar` world, and each of them has a `wit` directory in root of their
source tree containing the WIT files describing their respective worlds.  In
that case, we can use `componentize-go -w com:example/foo -w com:example/bar -m
example.com/foo -m example.com/bar build` to build our app, and
`componentize-go` will use `go list` to find the WIT files, resolve the worlds,
and union them together to produce the final component type.

Note that I've also removed the `wat` dependency because `go build` always
generates a binary Wasm file, so no need to check for or parse WAT.

Fixes #28

Author: dicej

Cargo.toml

@@ -37,7 +37,6 @@ allow_attributes_without_reason = 'warn'
 anyhow = { workspace = true}
 clap = { version = "4.5.60", features = ["derive"] }
 regex = "1.12.3"
-wat = { version = "1.245.1"}
 wit-bindgen-go = { git = "https://github.com/bytecodealliance/wit-bindgen", rev = "3ee9fe20a5bce398360d5d291e81a4224a6d7c76" }
 wit-component = "0.245.1"
 wit-parser = "0.245.1"

src/cmd_bindings.rs

@@ -4,16 +4,17 @@ use std::path::{Path, PathBuf};
 
 #[allow(clippy::too_many_arguments)]
 pub fn generate_bindings(
-    wit_path: &[impl AsRef<Path>],
-    world: Option<&str>,
+    paths: &[impl AsRef<Path>],
+    modules: &[String],
+    worlds: &[String],
     features: &[String],
     all_features: bool,
     generate_stubs: bool,
     should_format: bool,
     output: Option<&Path>,
     pkg_name: Option<String>,
 ) -> Result<()> {
-    let (mut resolve, world) = parse_wit(wit_path, world, features, all_features)?;
+    let (mut resolve, world) = parse_wit(paths, modules, worlds, features, all_features)?;
     let mut files = Default::default();
 
     let format = if should_format {

src/command.rs

@@ -31,9 +31,24 @@ pub struct WitOpts {
     #[arg(long, short = 'd')]
     pub wit_path: Vec<PathBuf>,
 
-    /// Name of world to target (or default world if `None`).
+    /// The name of a Go module whose source contains WIT document(s).
+    ///
+    /// This may be specified more than once, for example:
+    /// `-m github.com/example/foo -m github.com/example/bar`.
+    ///
+    /// The module must have already been added to the project using `go get`,
+    /// and its source directory must be discoverable via `go list`.  That
+    /// directory should have a subdirectory named "wit", which will be added to
+    /// the set of WIT paths to search.
+    #[arg(long, short = 'm')]
+    pub wit_module: Vec<String>,
+
+    /// Name of world to target (or default world if not specified).
+    ///
+    /// This may be specified more than once, in which case the worlds will be
+    /// merged.
     #[arg(long, short = 'w')]
-    pub world: Option<String>,
+    pub world: Vec<String>,
 
     /// Whether or not to activate all WIT features when processing WIT files.
     ///
@@ -156,7 +171,8 @@ fn build(wit_opts: WitOpts, build: Build) -> Result<()> {
         embed_wit(
             &module,
             &wit_opts.wit_path,
-            wit_opts.world.as_deref(),
+            &wit_opts.wit_module,
+            &wit_opts.world,
             &wit_opts.features,
             wit_opts.all_features,
         )?;
@@ -182,7 +198,8 @@ fn test(wit_opts: WitOpts, test: Test) -> Result<()> {
             embed_wit(
                 &module,
                 &wit_opts.wit_path,
-                wit_opts.world.as_deref(),
+                &wit_opts.wit_module,
+                &wit_opts.world,
                 &wit_opts.features,
                 wit_opts.all_features,
             )?;
@@ -197,8 +214,9 @@ fn test(wit_opts: WitOpts, test: Test) -> Result<()> {
 
 fn bindings(wit_opts: WitOpts, bindings: Bindings) -> Result<()> {
     generate_bindings(
-        wit_opts.wit_path.as_ref(),
-        wit_opts.world.as_deref(),
+        &wit_opts.wit_path,
+        &wit_opts.wit_module,
+        &wit_opts.world,
         &wit_opts.features,
         wit_opts.all_features,
         bindings.generate_stubs,

src/utils.rs

@@ -1,21 +1,22 @@
-use anyhow::{Context, Result, anyhow};
+use anyhow::{Context, Result, anyhow, bail};
 use std::{
     path::{Path, PathBuf},
     process::Command,
 };
-use wit_parser::{PackageId, Resolve, WorldId};
+use wit_parser::{CloneMaps, Package, PackageId, PackageName, Resolve, Stability, World, WorldId};
 
 pub fn parse_wit(
     paths: &[impl AsRef<Path>],
-    world: Option<&str>,
+    modules: &[String],
+    worlds: &[String],
     features: &[String],
     all_features: bool,
 ) -> Result<(Resolve, WorldId)> {
     // If no WIT directory was provided as a parameter and none were referenced
     // by Go packages, use ./wit by default.
-    if paths.is_empty() {
+    if paths.is_empty() && modules.is_empty() {
         let paths = &[Path::new("wit")];
-        return parse_wit(paths, world, features, all_features);
+        return parse_wit(paths, modules, worlds, features, all_features);
     }
     debug_assert!(!paths.is_empty(), "The paths should not be empty");
 
@@ -39,7 +40,72 @@ pub fn parse_wit(
         main_packages.push(pkg);
     }
 
-    let world = resolve.select_world(&main_packages, world)?;
+    for module in modules {
+        let mut command = std::process::Command::new("go");
+        let output = command
+            .args([
+                "list",
+                "-mod=readonly",
+                "-m",
+                "-f",
+                "{{.Dir}}",
+                module.as_str(),
+            ])
+            .output()?;
+        if !output.status.success() {
+            bail!(
+                "`go list` failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+        }
+        let (pkg, _files) = resolve
+            .push_path(PathBuf::from(String::from_utf8(output.stdout)?.trim()).join("wit"))?;
+        main_packages.push(pkg);
+    }
+
+    let world = match worlds {
+        [] => resolve.select_world(&main_packages, None)?,
+        [world] => resolve.select_world(&main_packages, Some(world))?,
+        worlds => {
+            let worlds = worlds
+                .iter()
+                .map(|world| resolve.select_world(&main_packages, Some(world)))
+                .collect::<Result<Vec<_>>>()?;
+
+            let union_package = resolve.packages.alloc(Package {
+                name: PackageName {
+                    namespace: "componentize-go".into(),
+                    name: "union".into(),
+                    version: None,
+                },
+                docs: Default::default(),
+                interfaces: Default::default(),
+                worlds: Default::default(),
+            });
+
+            let union_world = resolve.worlds.alloc(World {
+                name: "union".into(),
+                imports: Default::default(),
+                exports: Default::default(),
+                package: Some(union_package),
+                docs: Default::default(),
+                stability: Stability::Unknown,
+                includes: Default::default(),
+                span: Default::default(),
+            });
+
+            resolve.packages[union_package]
+                .worlds
+                .insert("union".into(), union_world);
+
+            for &world in &worlds {
+                resolve.merge_worlds(world, union_world, &mut CloneMaps::default())?;
+            }
+
+            union_world
+        }
+    };
+
     Ok((resolve, world))
 }
 
@@ -53,14 +119,15 @@ pub fn make_path_absolute(p: &PathBuf) -> Result<PathBuf> {
 }
 
 pub fn embed_wit(
-    wasm_file: &PathBuf,
-    wit_path: &[PathBuf],
-    world: Option<&str>,
+    wasm_file: &Path,
+    paths: &[PathBuf],
+    modules: &[String],
+    worlds: &[String],
     features: &[String],
     all_features: bool,
 ) -> Result<()> {
-    let mut wasm = wat::Parser::new().parse_file(wasm_file)?;
-    let (resolve, world_id) = parse_wit(wit_path, world, features, all_features)?;
+    let mut wasm = std::fs::read(wasm_file)?;
+    let (resolve, world_id) = parse_wit(paths, modules, worlds, features, all_features)?;
     wit_component::embed_component_metadata(
         &mut wasm,
         &resolve,