support for local paths, also always build it there instead of our cache

Author: Firestar99

crates/cargo-gpu/src/install.rs

@@ -1,14 +1,14 @@
 //! Install a dedicated per-shader crate that has the `rust-gpu` compiler in it.
 
-use anyhow::Context as _;
-use std::io::Write as _;
-use std::path::Path;
-
 use crate::args::InstallArgs;
 use crate::spirv_source::{
     get_channel_from_rustc_codegen_spirv_build_script, get_package_from_crate,
 };
 use crate::{cache_dir, spirv_source::SpirvSource, target_spec_dir};
+use anyhow::Context as _;
+use log::trace;
+use std::io::Write as _;
+use std::path::Path;
 
 /// Metadata for the compile targets supported by `rust-gpu`
 const TARGET_SPECS: &[(&str, &str)] = &[
@@ -85,21 +85,32 @@ pub struct Install {
 impl Install {
     /// Create the `rustc_codegen_spirv_dummy` crate that depends on `rustc_codegen_spirv`
     fn write_source_files(source: &SpirvSource, checkout: &Path) -> anyhow::Result<()> {
+        // skip writing a dummy project if we use a local rust-gpu checkout
+        if matches!(source, SpirvSource::Path { .. }) {
+            return Ok(());
+        }
+        log::debug!(
+            "writing `rustc_codegen_spirv_dummy` source files into '{}'",
+            checkout.display()
+        );
+
         {
+            trace!("writing dummy main.rs");
             let main = "fn main() {}";
             let src = checkout.join("src");
             std::fs::create_dir_all(&src).context("creating directory for 'src'")?;
             std::fs::write(src.join("main.rs"), main).context("writing 'main.rs'")?;
         };
 
         {
+            trace!("writing dummy Cargo.toml");
             let version_spec = match &source {
                 SpirvSource::CratesIO(version) => {
                     format!("version = \"{}\"", version)
                 }
                 SpirvSource::Git { url, rev } => format!("git = \"{url}\"\nrev = \"{rev}\""),
                 SpirvSource::Path {
-                    rust_gpu_path,
+                    rust_gpu_repo_root: rust_gpu_path,
                     version,
                 } => {
                     let mut new_path = rust_gpu_path.to_owned();
@@ -157,28 +168,37 @@ package = "rustc_codegen_spirv"
             self.spirv_install.spirv_builder_source.as_deref(),
             self.spirv_install.spirv_builder_version.as_deref(),
         )?;
+        let source_is_path = matches!(source, SpirvSource::Path { .. });
         let checkout = source.install_dir()?;
 
         let dylib_filename = format!(
             "{}rustc_codegen_spirv{}",
             std::env::consts::DLL_PREFIX,
             std::env::consts::DLL_SUFFIX
         );
-        let dest_dylib_path = checkout.join(&dylib_filename);
-        if dest_dylib_path.is_file() {
-            log::info!(
-                "cargo-gpu artifacts are already installed in '{}'",
-                checkout.display()
-            );
+
+        let dest_dylib_path;
+        if source_is_path {
+            dest_dylib_path = checkout
+                .join("target")
+                .join("release")
+                .join(&dylib_filename);
+        } else {
+            dest_dylib_path = checkout.join(&dylib_filename);
+            if dest_dylib_path.is_file() {
+                log::info!(
+                    "cargo-gpu artifacts are already installed in '{}'",
+                    checkout.display()
+                );
+            }
         }
 
-        if dest_dylib_path.is_file() && !self.spirv_install.force_spirv_cli_rebuild {
+        if !source_is_path
+            && dest_dylib_path.is_file()
+            && !self.spirv_install.force_spirv_cli_rebuild
+        {
             log::info!("...and so we are aborting the install step.");
         } else {
-            log::debug!(
-                "writing `rustc_codegen_spirv_dummy` source files into '{}'",
-                checkout.display()
-            );
             Self::write_source_files(&source, &checkout).context("writing source files")?;
 
             log::debug!("resolving toolchain version to use");
@@ -196,10 +216,6 @@ package = "rustc_codegen_spirv"
             )
             .context("ensuring toolchain and components exist")?;
 
-            log::debug!("write_target_spec_files");
-            self.write_target_spec_files()
-                .context("writing target spec files")?;
-
             crate::user_output!("Compiling `rustc_codegen_spirv` from source {}\n", source,);
 
             let mut build_command = std::process::Command::new("cargo");
@@ -208,6 +224,9 @@ package = "rustc_codegen_spirv"
                 .arg(format!("+{}", toolchain_channel))
                 .args(["build", "--release"])
                 .env_remove("RUSTC");
+            if source_is_path {
+                build_command.args(["-p", "rustc_codegen_spirv", "--lib"]);
+            }
 
             log::debug!("building artifacts with `{build_command:?}`");
 
@@ -231,11 +250,18 @@ package = "rustc_codegen_spirv"
                 .join(&dylib_filename);
             if dylib_path.is_file() {
                 log::info!("successfully built {}", dylib_path.display());
-                std::fs::rename(&dylib_path, &dest_dylib_path).context("renaming dylib path")?;
+                if !source_is_path {
+                    std::fs::rename(&dylib_path, &dest_dylib_path)
+                        .context("renaming dylib path")?;
+                }
             } else {
                 log::error!("could not find {}", dylib_path.display());
                 anyhow::bail!("`rustc_codegen_spirv` build failed");
             }
+
+            log::debug!("write_target_spec_files");
+            self.write_target_spec_files()
+                .context("writing target spec files")?;
         }
 
         self.spirv_install.dylib_path = dest_dylib_path;

crates/cargo-gpu/src/spirv_source.rs

@@ -5,7 +5,7 @@
 //! From there we can look at the source code to get the required Rust toolchain.
 
 use anyhow::{anyhow, Context as _};
-use cargo_metadata::camino::Utf8PathBuf;
+use cargo_metadata::camino::{Utf8Path, Utf8PathBuf};
 use cargo_metadata::semver::Version;
 use cargo_metadata::{MetadataCommand, Package};
 use std::fs;
@@ -41,7 +41,7 @@ pub enum SpirvSource {
     /// then the source of `rust-gpu` is `Path`.
     Path {
         /// File path of rust-gpu repository
-        rust_gpu_path: Utf8PathBuf,
+        rust_gpu_repo_root: Utf8PathBuf,
         /// Version of specified rust-gpu repository
         version: Version,
     },
@@ -57,9 +57,9 @@ impl core::fmt::Display for SpirvSource {
             Self::CratesIO(version) => version.fmt(f),
             Self::Git { url, rev } => f.write_str(&format!("{url}+{rev}")),
             Self::Path {
-                rust_gpu_path,
+                rust_gpu_repo_root,
                 version,
-            } => f.write_str(&format!("{rust_gpu_path}+{version}")),
+            } => f.write_str(&format!("{rust_gpu_repo_root}+{version}")),
         }
     }
 }
@@ -102,10 +102,17 @@ impl SpirvSource {
     /// It needs to be dynamically created because an end-user might want to swap out the source,
     /// maybe using their own fork for example.
     pub fn install_dir(&self) -> anyhow::Result<PathBuf> {
-        let dir = crate::to_dirname(self.to_string().as_ref());
-        Ok(crate::cache_dir()?
-            .join("rustc_backend_spirv_install")
-            .join(dir))
+        match self {
+            SpirvSource::Path {
+                rust_gpu_repo_root, ..
+            } => Ok(rust_gpu_repo_root.as_std_path().to_owned()),
+            SpirvSource::CratesIO { .. } | SpirvSource::Git { .. } => {
+                let dir = crate::to_dirname(self.to_string().as_ref());
+                Ok(crate::cache_dir()?
+                    .join("rustc_backend_spirv_install")
+                    .join(dir))
+            }
+        }
     }
 
     /// Parse a string like:
@@ -144,18 +151,19 @@ impl SpirvSource {
                 }
             }
             None => {
-                let rust_gpu_path = spirv_std_package
+                let rust_gpu_repo_root = spirv_std_package
                     .manifest_path // rust-gpu/crates/spirv-std/Cargo.toml
-                    .parent()
-                    .unwrap() // rust-gpu/crates/spirv-std
-                    .parent()
-                    .unwrap() // rust-gpu/crates
-                    .parent()
-                    .unwrap() // rust-gpu
+                    .parent() // rust-gpu/crates/spirv-std
+                    .and_then(Utf8Path::parent) // rust-gpu/crates
+                    .and_then(Utf8Path::parent) // rust-gpu
+                    .context("selecting rust-gpu workspace root dir in local path")?
                     .to_owned();
+                if !rust_gpu_repo_root.is_dir() {
+                    anyhow::bail!("path {rust_gpu_repo_root} is not a directory");
+                }
                 let version = spirv_std_package.version.clone();
                 Self::Path {
-                    rust_gpu_path,
+                    rust_gpu_repo_root,
                     version,
                 }
             }