Spirv builder cleanup

crates/spirv-builder/README.md

@@ -11,12 +11,13 @@ It takes care of pulling in the `SPIR-V` backend for Rust, `rustc_codegen_spirv`
 ## Example
 
 ```rust,no_run
-use spirv_builder::{MetadataPrintout, SpirvBuilder};
-
+# use spirv_builder::SpirvBuilder;
+# 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    SpirvBuilder::new("my_shaders", "spirv-unknown-vulkan1.1")
-        .print_metadata(MetadataPrintout::Full)
-        .build()?;
+    let mut builder = SpirvBuilder::new("my_shaders", "spirv-unknown-vulkan1.3");
+    builder.build_script.defaults = true;
+    builder.build_script.env_shader_spv_path = Some(true);
+    builder.build()?;
     Ok(())
 }
 ```

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,
@@ -55,7 +55,7 @@ impl SpirvWatcher {
             .as_ref()
             .ok_or(SpirvBuilderError::MissingCratePath)?
             .clone();
-        if !matches!(builder.print_metadata, crate::MetadataPrintout::None) {
+        if builder.build_script.get_env_shader_spv_path() {
             return Err(SpirvWatcherError::WatchWithPrintMetadata.into());
         }
 
@@ -124,10 +124,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 = self.builder.invoke_rustc()?;
+            self.watch_leaf_deps(out.deps.iter().map(|d| d.as_ref()));
+            Ok(out.compile_result)
         })();
         match result {
             Ok(result) => {
@@ -155,16 +154,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)
+        }
     }
 }
 

examples/multibuilder/src/main.rs

@@ -1,13 +1,11 @@
-use spirv_builder::{MetadataPrintout, SpirvBuilder};
+use spirv_builder::SpirvBuilder;
 
 fn main() {
-    let result = SpirvBuilder::new(
+    let mut builder = SpirvBuilder::new(
         concat!(env!("CARGO_MANIFEST_DIR"), "/../shaders/sky-shader"),
         "spirv-unknown-spv1.3",
-    )
-    .print_metadata(MetadataPrintout::DependencyOnly)
-    .multimodule(true)
-    .build()
-    .unwrap();
+    );
+    builder.multimodule = true;
+    let result = builder.build().unwrap();
     println!("{result:#?}");
 }

examples/runners/ash/src/main.rs

@@ -78,7 +78,7 @@ use ash::util::read_spv;
 use clap::{Parser, ValueEnum};
 use raw_window_handle::HasDisplayHandle as _;
 use shared::ShaderConstants;
-use spirv_builder::{MetadataPrintout, SpirvBuilder};
+use spirv_builder::SpirvBuilder;
 use std::{
     fs::File,
     path::PathBuf,
@@ -259,7 +259,6 @@ pub fn compile_shaders(shader: &RustGPUShader) -> anyhow::Result<Vec<u32>> {
         .collect::<PathBuf>();
 
     let compile_result = SpirvBuilder::new(crate_path, "spirv-unknown-vulkan1.3")
-        .print_metadata(MetadataPrintout::None)
         .shader_panic_strategy(spirv_builder::ShaderPanicStrategy::DebugPrintfThenExit {
             print_inputs: true,
             print_backtrace: true,

examples/runners/wgpu/builder/src/main.rs

@@ -1,18 +1,18 @@
-use spirv_builder::{MetadataPrintout, SpirvBuilder};
+use spirv_builder::SpirvBuilder;
 use std::env;
 use std::error::Error;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 fn build_shader(path_to_crate: &str, codegen_names: bool) -> Result<(), Box<dyn Error>> {
-    let builder_dir = &Path::new(env!("CARGO_MANIFEST_DIR"));
-    let path_to_crate = builder_dir.join(path_to_crate);
-    let result = SpirvBuilder::new(path_to_crate, "spirv-unknown-vulkan1.1")
-        .print_metadata(MetadataPrintout::Full)
-        // Give this spirv-builder a unique target dir, so that rebuilding android and the main wgpu app's target dir
-        // don't clash and break each other's incremental
-        .target_dir_path("example-runner-wgpu-builder")
-        .build()?;
+    let path_to_crate = Path::new(env!("CARGO_MANIFEST_DIR")).join(path_to_crate);
+    let mut builder = SpirvBuilder::new(path_to_crate, "spirv-unknown-vulkan1.1");
+    builder.build_script.defaults = true;
+    builder.build_script.env_shader_spv_path = Some(true);
+    // Give this spirv-builder a unique target dir, so that rebuilding android and the main wgpu app's target dir
+    // don't clash and break each other's incremental
+    builder.target_dir_path = Some(PathBuf::from("example-runner-wgpu-builder"));
+    let result = builder.build()?;
     if codegen_names {
         let out_dir = env::var_os("OUT_DIR").unwrap();
         let dest_path = Path::new(&out_dir).join("entry_points.rs");

examples/runners/wgpu/src/lib.rs

@@ -129,7 +129,7 @@ fn maybe_watch(
 ) -> CompiledShaderModules {
     #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
     {
-        use spirv_builder::{CompileResult, MetadataPrintout, SpirvBuilder};
+        use spirv_builder::{CompileResult, SpirvBuilder};
         use std::path::PathBuf;
 
         let crate_name = match options.shader {
@@ -147,7 +147,6 @@ fn maybe_watch(
         let has_debug_printf = options.force_spirv_passthru;
 
         let builder = SpirvBuilder::new(crate_path, "spirv-unknown-vulkan1.1")
-            .print_metadata(MetadataPrintout::None)
             .shader_panic_strategy(if has_debug_printf {
                 spirv_builder::ShaderPanicStrategy::DebugPrintfThenExit {
                     print_inputs: true,

tests/difftests/lib/src/scaffold/shader/rust_gpu_shader.rs

@@ -38,7 +38,6 @@ impl RustComputeShader {
 impl SpirvShader for RustComputeShader {
     fn spirv_bytes(&self) -> anyhow::Result<(Vec<u8>, String)> {
         let mut builder = SpirvBuilder::new(&self.path, &self.target)
-            .print_metadata(spirv_builder::MetadataPrintout::None)
             .release(true)
             .multimodule(false)
             .shader_panic_strategy(spirv_builder::ShaderPanicStrategy::SilentExit)