Support lists of WIT directories on the CLI. (#1368)

Accept multiple WIT paths in the wit-bindgen CLI, using the same logic
as the multiple WIT paths accepted by the `path` parameter in the
Rust bindgen macro.

Also, document that list-of-WIT interfaces, in the Rust macro and now
the wit-bindgen CLI, have a topological ordering requirement which may
be lifted in the future.

Author: sunfishcode

Cargo.lock

@@ -33,13 +33,13 @@ prettyplease = "0.2.20"
 syn = { version = "2.0.89", features = ["printing"] }
 futures = "0.3.31"
 
-wat = "1.237.0"
-wasmparser = "0.237.0"
-wasm-encoder = "0.237.0"
-wasm-metadata = { version = "0.237.0", default-features = false }
-wit-parser = "0.237.0"
-wit-component = "0.237.0"
-wasm-compose = "0.237.0"
+wat = "1.238.0"
+wasmparser = "0.238.0"
+wasm-encoder = "0.238.0"
+wasm-metadata = { version = "0.238.0", default-features = false }
+wit-parser = "0.238.0"
+wit-component = "0.238.0"
+wasm-compose = "0.238.0"
 
 wit-bindgen-core = { path = 'crates/core', version = '0.44.0' }
 wit-bindgen-c = { path = 'crates/c', version = '0.44.0' }

Cargo.toml

@@ -52,7 +52,7 @@ struct Config {
 
 /// The source of the wit package definition
 enum Source {
-    /// A path to a wit directory
+    /// A list of paths to wit directories
     Paths(Vec<PathBuf>),
     /// Inline sources have an optional path to a directory of their dependencies
     Inline(String, Option<Vec<PathBuf>>),
@@ -174,9 +174,10 @@ impl Parse for Config {
                 )]));
             }
         }
-        let (resolve, pkgs, files) =
+        let (resolve, main_packages, files) =
             parse_source(&source, &features).map_err(|err| anyhow_to_syn(call_site, err))?;
-        let world = select_world(&resolve, &pkgs, world.as_deref())
+        let world = resolve
+            .select_world(&main_packages, world.as_deref())
             .map_err(|e| anyhow_to_syn(call_site, e))?;
         Ok(Config {
             opts,
@@ -188,43 +189,6 @@ impl Parse for Config {
     }
 }
 
-fn select_world(
-    resolve: &Resolve,
-    pkgs: &[PackageId],
-    world: Option<&str>,
-) -> anyhow::Result<WorldId> {
-    if pkgs.len() == 1 {
-        resolve.select_world(pkgs[0], world)
-    } else {
-        assert!(!pkgs.is_empty());
-        match world {
-            Some(name) => {
-                if !name.contains(":") {
-                    anyhow::bail!(
-                        "with multiple packages a fully qualified \
-                         world name must be specified"
-                    )
-                }
-
-                // This will ignore the package argument due to the fully
-                // qualified name being used.
-                resolve.select_world(pkgs[0], world)
-            }
-            None => {
-                let worlds = pkgs
-                    .iter()
-                    .filter_map(|p| resolve.select_world(*p, None).ok())
-                    .collect::<Vec<_>>();
-                match &worlds[..] {
-                    [] => anyhow::bail!("no packages have a world"),
-                    [world] => Ok(*world),
-                    _ => anyhow::bail!("multiple packages have a world, must specify which to use"),
-                }
-            }
-        }
-    }
-}
-
 /// Parse the source
 fn parse_source(
     source: &Option<Source>,

crates/guest-rust/macro/src/lib.rs

@@ -652,7 +652,9 @@
 ///     // ["../path/to/wit1", "../path/to/wit2"]
 ///     // Usually used in testing, our test suite may want to generate code
 ///     // from wit files located in multiple paths within a single mod, and we
-///     // don't want to copy these files again.
+///     // don't want to copy these files again. Currently these locations must
+///     // be ordered, as later paths can't contain dependencies on earlier
+///     // paths. This restriction may be lifted in the future.
 ///     path: "../path/to/wit",
 ///
 ///     // Enables passing "inline WIT". If specified this is the default

crates/guest-rust/src/lib.rs

@@ -143,9 +143,9 @@ pub fn run_component_codegen_test(
 fn parse_wit(path: &Path) -> (Resolve, WorldId) {
     let mut resolve = Resolve::default();
     let (pkg, _files) = resolve.push_path(path).unwrap();
-    let world = resolve.select_world(pkg, None).unwrap_or_else(|_| {
+    let world = resolve.select_world(&[pkg], None).unwrap_or_else(|_| {
         // note: if there are multiples worlds in the wit package, we assume the "imports" world
-        resolve.select_world(pkg, Some("imports")).unwrap()
+        resolve.select_world(&[pkg], Some("imports")).unwrap()
     });
     (resolve, world)
 }

crates/test-helpers/src/lib.rs

@@ -342,7 +342,7 @@ impl Runner<'_> {
         let mut worlds = Vec::new();
 
         let mut push_world = |kind: Kind, name: &str| -> Result<()> {
-            let world = resolve.select_world(pkg, Some(name)).with_context(|| {
+            let world = resolve.select_world(&[pkg], Some(name)).with_context(|| {
                 format!("failed to find expected `{name}` world to generate bindings")
             })?;
             worlds.push((world, kind));
@@ -582,8 +582,12 @@ impl Runner<'_> {
         let mut resolve = wit_parser::Resolve::default();
         let (pkg, _) = resolve.push_path(test).context("failed to load WIT")?;
         let world = resolve
-            .select_world(pkg, None)
-            .or_else(|err| resolve.select_world(pkg, Some("imports")).map_err(|_| err))
+            .select_world(&[pkg], None)
+            .or_else(|err| {
+                resolve
+                    .select_world(&[pkg], Some("imports"))
+                    .map_err(|_| err)
+            })
             .context("failed to select a world for bindings generation")?;
         let world = resolve.worlds[world].name.clone();
 
@@ -992,7 +996,7 @@ status: {}",
         let (pkg, _) = resolve
             .push_path(&compile.component.bindgen.wit_path)
             .context("failed to load WIT")?;
-        let world = resolve.select_world(pkg, Some(&compile.component.bindgen.world))?;
+        let world = resolve.select_world(&[pkg], Some(&compile.component.bindgen.world))?;
         let mut module = fs::read(&p1).context("failed to read wasm file")?;
         let encoded = wit_component::metadata::encode(&resolve, world, StringEncoding::UTF8, None)?;
 

crates/test/src/lib.rs

@@ -85,14 +85,18 @@ struct Common {
     #[clap(long = "out-dir")]
     out_dir: Option<PathBuf>,
 
-    /// Location of WIT file(s) to generate bindings for.
+    /// Locations of WIT file(s) to generate bindings for.
     ///
-    /// This path can be either a directory containing `*.wit` files, a `*.wit`
-    /// file itself, or a `*.wasm` file which is a wasm-encoded WIT package.
-    /// Most of the time it's likely to be a directory containing `*.wit` files
-    /// with an optional `deps` folder inside of it.
+    /// These paths can be either directories containing `*.wit` files, `*.wit`
+    /// files themselves, or `*.wasm` files which are wasm-encoded WIT packages.
+    /// Most of the time they're likely to be directories containing `*.wit`
+    /// files with optional `deps` folders inside of them.
+    ///
+    /// Currently these locations must be ordered, as later paths can't contain
+    /// dependencies on earlier paths. This restriction may be lifted in the
+    /// future.
     #[clap(value_name = "WIT", index = 1)]
-    wit: PathBuf,
+    wit: Vec<PathBuf>,
 
     /// Optionally specified world that bindings are generated for.
     ///
@@ -219,8 +223,12 @@ fn gen_world(
             resolve.features.insert(feature.to_string());
         }
     }
-    let (pkg, _files) = resolve.push_path(&opts.wit)?;
-    let world = resolve.select_world(pkg, opts.world.as_deref())?;
+    let mut main_packages = Vec::new();
+    for wit in &opts.wit {
+        let (pkg, _files) = resolve.push_path(wit)?;
+        main_packages.push(pkg);
+    }
+    let world = resolve.select_world(&main_packages, opts.world.as_deref())?;
     generator.generate(&resolve, world, files)?;
 
     Ok(())