cache cargo metadata

schell · schell · commit 927ba3ad5fb4 · 2025-11-06T15:31:50.000+13:00
diff --git a/crates/cargo-gpu/src/build.rs b/crates/cargo-gpu/src/build.rs
@@ -59,10 +59,10 @@ impl Build {
     /// Entrypoint
     pub fn run(&mut self) -> anyhow::Result<()> {
         let installed_backend = self.install.run()?;
+        let mut metadata = crate::metadata::MetadataCache::default();
 
         if let Some(package) = self.install.package.as_ref() {
-            self.install.shader_crate =
-                crate::metadata::Metadata::resolve_package_to_shader_crate(package)?;
+            self.install.shader_crate = metadata.resolve_package_to_shader_crate(package)?;
         }
 
         let _lockfile_mismatch_handler = LockfileMismatchHandler::new(
diff --git a/crates/cargo-gpu/src/config.rs b/crates/cargo-gpu/src/config.rs
@@ -2,6 +2,8 @@
 use anyhow::Context as _;
 use clap::Parser as _;
 
+use crate::metadata::MetadataCache;
+
 /// Config
 pub struct Config;
 
@@ -25,8 +27,9 @@ impl Config {
     pub fn clap_command_with_cargo_config(
         shader_crate_path: &std::path::PathBuf,
         mut env_args: Vec<String>,
+        metadata: &mut MetadataCache,
     ) -> anyhow::Result<crate::build::Build> {
-        let mut config = crate::metadata::Metadata::as_json(shader_crate_path)?;
+        let mut config = metadata.as_json(shader_crate_path)?;
 
         env_args.retain(|arg| !(arg == "build" || arg == "install"));
         let cli_args_json = Self::cli_args_to_json(env_args)?;
@@ -100,6 +103,7 @@ mod test {
                 "--debug".to_owned(),
                 "--auto-install-rust-toolchain".to_owned(),
             ],
+            &mut MetadataCache::default(),
         )
         .unwrap();
         assert!(!args.build.spirv_builder.release);
@@ -122,7 +126,12 @@ mod test {
         )
         .unwrap();
 
-        let args = Config::clap_command_with_cargo_config(&shader_crate_path, vec![]).unwrap();
+        let args = Config::clap_command_with_cargo_config(
+            &shader_crate_path,
+            vec![],
+            &mut MetadataCache::default(),
+        )
+        .unwrap();
         assert!(!args.build.spirv_builder.release);
         assert!(args.install.auto_install_rust_toolchain);
     }
@@ -146,7 +155,12 @@ mod test {
     fn string_from_cargo() {
         let shader_crate_path = update_cargo_output_dir();
 
-        let args = Config::clap_command_with_cargo_config(&shader_crate_path, vec![]).unwrap();
+        let args = Config::clap_command_with_cargo_config(
+            &shader_crate_path,
+            vec![],
+            &mut MetadataCache::default(),
+        )
+        .unwrap();
         if cfg!(target_os = "windows") {
             assert_eq!(args.build.output_dir, std::path::Path::new("C:/the/moon"));
         } else {
@@ -166,6 +180,7 @@ mod test {
                 "--output-dir".to_owned(),
                 "/the/river".to_owned(),
             ],
+            &mut MetadataCache::default(),
         )
         .unwrap();
         assert_eq!(args.build.output_dir, std::path::Path::new("/the/river"));
@@ -185,7 +200,12 @@ mod test {
         )
         .unwrap();
 
-        let args = Config::clap_command_with_cargo_config(&shader_crate_path, vec![]).unwrap();
+        let args = Config::clap_command_with_cargo_config(
+            &shader_crate_path,
+            vec![],
+            &mut MetadataCache::default(),
+        )
+        .unwrap();
         assert_eq!(
             args.build.spirv_builder.capabilities,
             vec![
@@ -207,6 +227,7 @@ mod test {
                 "--manifest-file".to_owned(),
                 "mymanifest".to_owned(),
             ],
+            &mut MetadataCache::default(),
         )
         .unwrap();
         assert_eq!(args.build.manifest_file, "mymanifest".to_owned());
diff --git a/crates/cargo-gpu/src/lib.rs b/crates/cargo-gpu/src/lib.rs
@@ -70,6 +70,7 @@ mod target_specs;
 mod test;
 
 pub use install::*;
+pub use metadata::MetadataCache;
 pub use spirv_builder;
 
 /// Central function to write to the user.
@@ -122,12 +123,19 @@ impl Command {
     /// # Errors
     /// Any errors during execution, usually printed to the user
     #[inline]
-    pub fn run(&self, env_args: Vec<String>) -> anyhow::Result<()> {
+    pub fn run(
+        &self,
+        env_args: Vec<String>,
+        metadata_cache: &mut metadata::MetadataCache,
+    ) -> anyhow::Result<()> {
         match &self {
             Self::Install(install) => {
                 let shader_crate_path = &install.shader_crate;
-                let command =
-                    config::Config::clap_command_with_cargo_config(shader_crate_path, env_args)?;
+                let command = config::Config::clap_command_with_cargo_config(
+                    shader_crate_path,
+                    env_args,
+                    metadata_cache,
+                )?;
                 log::debug!(
                     "installing with final merged arguments: {:#?}",
                     command.install
@@ -136,8 +144,11 @@ impl Command {
             }
             Self::Build(build) => {
                 let shader_crate_path = &build.install.shader_crate;
-                let mut command =
-                    config::Config::clap_command_with_cargo_config(shader_crate_path, env_args)?;
+                let mut command = config::Config::clap_command_with_cargo_config(
+                    shader_crate_path,
+                    env_args,
+                    metadata_cache,
+                )?;
                 log::debug!("building with final merged arguments: {command:#?}");
 
                 if command.build.watch {
diff --git a/crates/cargo-gpu/src/main.rs b/crates/cargo-gpu/src/main.rs
@@ -37,5 +37,6 @@ fn run() -> anyhow::Result<()> {
         .collect::<Vec<_>>();
     log::trace!("CLI args: {env_args:#?}");
     let cli = Cli::parse_from(&env_args);
-    cli.command.run(env_args)
+    let mut metadata_cache = cargo_gpu::MetadataCache::default();
+    cli.command.run(env_args, &mut metadata_cache)
 }
diff --git a/crates/cargo-gpu/src/metadata.rs b/crates/cargo-gpu/src/metadata.rs
@@ -1,19 +1,49 @@
 //! Get config from the shader crate's `Cargo.toml` `[*.metadata.rust-gpu.*]`
 
+use std::collections::HashMap;
+
 use anyhow::Context as _;
 use cargo_metadata::MetadataCommand;
 use serde_json::Value;
 
-/// `Metadata` refers to the `[metadata.*]` section of `Cargo.toml` that `cargo` formally
+/// A cache of metadata from various `Cargo.toml` files.
+///
+/// "Metadata" refers to the `[metadata.*]` section of `Cargo.toml` that `cargo` formally
 /// ignores so that packages can implement their own behaviour with it.
-#[derive(Debug)]
-pub struct Metadata;
+#[derive(Debug, Default)]
+pub struct MetadataCache {
+    /// Cached result of `MetadataCommand::new().exec()`.
+    inner: HashMap<std::path::PathBuf, cargo_metadata::Metadata>,
+}
+
+impl MetadataCache {
+    fn get_metadata(
+        &mut self,
+        maybe_path_to_manifest_dir: Option<&std::path::Path>,
+    ) -> anyhow::Result<&cargo_metadata::Metadata> {
+        let path = if let Some(path) = maybe_path_to_manifest_dir {
+            path.to_path_buf()
+        } else {
+            std::env::current_dir().context("cannot determine the current working directory")?
+        };
+
+        if !self.inner.contains_key(&path) {
+            let metadata = MetadataCommand::new().current_dir(&path).exec()?;
+            self.inner.insert(path.clone(), metadata);
+        }
+
+        // UNWRAP: safe because we just inserted it
+        Ok(self.inner.get(&path).unwrap())
+    }
 
-impl Metadata {
     /// Resolve a package name to a crate directory.
-    pub fn resolve_package_to_shader_crate(package: &str) -> anyhow::Result<std::path::PathBuf> {
+    pub fn resolve_package_to_shader_crate(
+        &mut self,
+        package: &str,
+    ) -> anyhow::Result<std::path::PathBuf> {
         log::debug!("resolving package '{package}' to shader crate");
-        let metadata = MetadataCommand::new().exec()?;
+        let metadata = self.get_metadata(None)?;
+
         let meta_package = metadata
             .packages
             .iter()
@@ -39,9 +69,9 @@ impl Metadata {
     /// First we generate the CLI arg defaults as JSON. Then on top of those we merge any config
     /// from the workspace `Cargo.toml`, then on top of those we merge any config from the shader
     /// crate's `Cargo.toml`.
-    pub fn as_json(path: &std::path::PathBuf) -> anyhow::Result<Value> {
+    pub fn as_json(&mut self, path: &std::path::PathBuf) -> anyhow::Result<Value> {
         log::debug!("reading package metadata from {}", path.display());
-        let cargo_json = Self::get_cargo_toml_as_json(path)?;
+        let cargo_json = self.get_cargo_toml_as_json(path)?;
         let config = Self::merge_configs(&cargo_json, path)?;
         Ok(config)
     }
@@ -90,9 +120,10 @@ impl Metadata {
 
     /// Convert a `Cargo.toml` to JSON
     fn get_cargo_toml_as_json(
+        &mut self,
         path: &std::path::PathBuf,
     ) -> anyhow::Result<cargo_metadata::Metadata> {
-        Ok(MetadataCommand::new().current_dir(path).exec()?)
+        self.get_metadata(Some(path.as_path())).cloned()
     }
 
     /// Get any `rust-gpu` metadata set in the crate's `Cargo.toml`
@@ -161,7 +192,7 @@ mod test {
             .exec()
             .unwrap();
         metadata.packages.first_mut().unwrap().metadata = serde_json::json!({});
-        let configs = Metadata::merge_configs(&metadata, Path::new("./")).unwrap();
+        let configs = MetadataCache::merge_configs(&metadata, Path::new("./")).unwrap();
         assert_eq!(configs["build"]["release"], Value::Bool(true));
         assert_eq!(
             configs["install"]["auto_install_rust_toolchain"],
@@ -185,7 +216,7 @@ mod test {
                 }
             }
         });
-        let configs = Metadata::merge_configs(&metadata, Path::new("./")).unwrap();
+        let configs = MetadataCache::merge_configs(&metadata, Path::new("./")).unwrap();
         assert_eq!(configs["build"]["release"], Value::Bool(false));
         assert_eq!(
             configs["install"]["auto_install_rust_toolchain"],
@@ -214,7 +245,7 @@ mod test {
                 }
             }
         });
-        let configs = Metadata::merge_configs(&metadata, Path::new(".")).unwrap();
+        let configs = MetadataCache::merge_configs(&metadata, Path::new(".")).unwrap();
         assert_eq!(configs["build"]["release"], Value::Bool(false));
         assert_eq!(
             configs["install"]["auto_install_rust_toolchain"],

Original file line number	Diff line number	Diff line change
`@@ -37,5 +37,6 @@ fn run() -> anyhow::Result<()> {`
`37`	`37`	`.collect::<Vec<_>>();`
`38`	`38`	`log::trace!("CLI args: {env_args:#?}");`
`39`	`39`	`let cli = Cli::parse_from(&env_args);`
`40`		`- cli.command.run(env_args)`
	`40`	`+ let mut metadata_cache = cargo_gpu::MetadataCache::default();`
	`41`	`+ cli.command.run(env_args, &mut metadata_cache)`
`41`	`42`	`}`