spirv-builder: move metadata file parsing to invoke_rustc

Author: Firestar99

crates/spirv-builder/src/lib.rs

@@ -118,9 +118,9 @@ pub enum SpirvBuilderError {
         "`multimodule: true` build cannot be used together with `build_script.env_shader_spv_path: true`"
     )]
     MultiModuleWithEnvShaderSpvPath,
-    #[error("multi-module metadata file missing")]
+    #[error("some metadata file is missing")]
     MetadataFileMissing(#[from] std::io::Error),
-    #[error("unable to parse multi-module metadata file")]
+    #[error("unable to parse some metadata file")]
     MetadataFileMalformed(#[from] serde_json::Error),
     #[error(
         "`{ARTIFACT_SUFFIX}` artifact not found in (supposedly successful) build output.\n--- build output ---\n{stdout}"
@@ -740,17 +740,13 @@ impl SpirvBuilder {
 
     /// Builds the module
     pub fn build(&self) -> Result<CompileResult, SpirvBuilderError> {
-        let metadata_file = invoke_rustc(self)?;
+        let out = invoke_rustc(self)?;
         if self.build_script.get_dependency_info() {
-            leaf_deps(&metadata_file, |artifact| {
-                println!("cargo:rerun-if-changed={artifact}");
-            })
-            // Close enough
-            .map_err(SpirvBuilderError::MetadataFileMissing)?;
+            for dep in &out.deps {
+                println!("cargo:rerun-if-changed={dep}");
+            }
         }
-        let metadata = self.parse_metadata_file(&metadata_file)?;
-
-        Ok(metadata)
+        Ok(out.compile_result)
     }
 
     pub(crate) fn parse_metadata_file(
@@ -888,8 +884,12 @@ fn join_checking_for_separators(strings: Vec<impl Borrow<str>>, sep: &str) -> St
     strings.join(sep)
 }
 
-// Returns path to the metadata json.
-fn invoke_rustc(builder: &SpirvBuilder) -> Result<PathBuf, SpirvBuilderError> {
+pub struct RustcOutput {
+    pub compile_result: CompileResult,
+    pub deps: Vec<RawString>,
+}
+
+fn invoke_rustc(builder: &SpirvBuilder) -> Result<RustcOutput, SpirvBuilderError> {
     let path_to_crate = builder
         .path_to_crate
         .as_ref()
@@ -1161,24 +1161,35 @@ fn invoke_rustc(builder: &SpirvBuilder) -> Result<PathBuf, SpirvBuilderError> {
     // that ended up on stdout instead of stderr.
     let stdout = String::from_utf8(build.stdout).unwrap();
     if build.status.success() {
-        get_sole_artifact(&stdout).ok_or(SpirvBuilderError::NoArtifactProduced { stdout })
+        let metadata_file =
+            get_sole_artifact(&stdout).ok_or(SpirvBuilderError::NoArtifactProduced { stdout })?;
+        let compile_result = builder.parse_metadata_file(&metadata_file)?;
+        let mut deps = Vec::new();
+        leaf_deps(&metadata_file, |artifact| {
+            deps.push(RawString::from(artifact));
+        })
+        .map_err(SpirvBuilderError::MetadataFileMissing)?;
+        Ok(RustcOutput {
+            compile_result,
+            deps,
+        })
     } else {
         Err(SpirvBuilderError::BuildFailed)
     }
 }
 
-#[derive(Deserialize)]
-struct RustcOutput {
-    reason: String,
-    filenames: Option<Vec<String>>,
-}
-
 const ARTIFACT_SUFFIX: &str = ".spv.json";
 
 fn get_sole_artifact(out: &str) -> Option<PathBuf> {
+    #[derive(Deserialize)]
+    struct RustcLine {
+        reason: String,
+        filenames: Option<Vec<String>>,
+    }
+
     let mut last_compiler_artifact = None;
     for line in out.lines() {
-        let Ok(msg) = serde_json::from_str::<RustcOutput>(line) else {
+        let Ok(msg) = serde_json::from_str::<RustcLine>(line) else {
             // Pass through invalid lines
             println!("{line}");
             continue;

crates/spirv-builder/src/watch.rs

@@ -1,7 +1,7 @@
-use crate::{SpirvBuilder, SpirvBuilderError, leaf_deps};
+use crate::{SpirvBuilder, SpirvBuilderError};
 use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher};
+use raw_string::RawStr;
 use rustc_codegen_spirv_types::CompileResult;
-use std::path::Path;
 use std::sync::mpsc::TryRecvError;
 use std::{
     collections::HashSet,
@@ -121,10 +121,9 @@ impl SpirvWatcher {
         }
 
         let result = (|| {
-            let metadata_file = crate::invoke_rustc(&self.builder)?;
-            let result = self.builder.parse_metadata_file(&metadata_file)?;
-            self.watch_leaf_deps(&metadata_file)?;
-            Ok(result)
+            let out = crate::invoke_rustc(&self.builder)?;
+            self.watch_leaf_deps(out.deps.iter().map(|d| d.as_ref()));
+            Ok(out.compile_result)
         })();
         match result {
             Ok(result) => {
@@ -152,16 +151,15 @@ impl SpirvWatcher {
         }
     }
 
-    fn watch_leaf_deps(&mut self, watch_path: &Path) -> Result<(), SpirvBuilderError> {
-        leaf_deps(watch_path, |artifact| {
-            let path = artifact.to_path().unwrap();
+    fn watch_leaf_deps<'a>(&mut self, deps: impl Iterator<Item = &'a RawStr>) {
+        for dep in deps {
+            let path = dep.to_path().unwrap();
             if self.watched_paths.insert(path.to_owned())
                 && let Err(err) = self.watcher.watch(path, RecursiveMode::NonRecursive)
             {
-                log::error!("files of cargo dependencies are not valid: {err}");
+                log::error!("failed to watch `{}`: {err}", path.display());
             }
-        })
-        .map_err(SpirvBuilderError::MetadataFileMissing)
+        }
     }
 }