Decouple install toolchain handling, add error types for it

Author: tuguzT

.gitignore

@@ -27,3 +27,4 @@ crates/shader-crate-template/manifest.json
 crates/shader-crate-template/rust_gpu_shader_crate_template.spv
 
 .idea
+.vscode

crates/cargo-gpu-cache/src/install_toolchain.rs

@@ -2,98 +2,41 @@
 
 use anyhow::Context as _;
 use crossterm::tty::IsTty as _;
+use rustc_codegen_spirv_cache::toolchain::{
+    ensure_toolchain_installation, REQUIRED_TOOLCHAIN_COMPONENTS,
+};
 
-/// Use `rustup` to install the toolchain and components, if not already installed.
-///
-/// Pretty much runs:
-///
-/// * rustup toolchain add nightly-2024-04-24
-/// * rustup component add --toolchain nightly-2024-04-24 rust-src rustc-dev llvm-tools
+use crate::user_output;
+
+/// Uses `rustup` to install the toolchain and all the [required components](REQUIRED_TOOLCHAIN_COMPONENTS),
+/// if not already installed, while additionally asking for the user consent.
 pub fn ensure_toolchain_and_components_exist(
     channel: &str,
     skip_toolchain_install_consent: bool,
 ) -> anyhow::Result<()> {
-    // Check for the required toolchain
-    let output_toolchain_list = std::process::Command::new("rustup")
-        .args(["toolchain", "list"])
-        .output()
-        .context("running rustup command")?;
-    anyhow::ensure!(
-        output_toolchain_list.status.success(),
-        "could not list installed toolchains"
-    );
-    let string_toolchain_list = String::from_utf8_lossy(&output_toolchain_list.stdout);
-    if string_toolchain_list
-        .split_whitespace()
-        .any(|toolchain| toolchain.starts_with(channel))
-    {
-        log::debug!("toolchain {channel} is already installed");
-    } else {
+    let on_toolchain_install = || {
         let message = format!("Rust {channel} with `rustup`");
         get_consent_for_toolchain_install(
             format!("Install {message}").as_ref(),
             skip_toolchain_install_consent,
         )?;
-        crate::user_output!("Installing {message}\n")?;
-
-        let output_toolchain_add = std::process::Command::new("rustup")
-            .args(["toolchain", "add"])
-            .arg(channel)
-            .stdout(std::process::Stdio::inherit())
-            .stderr(std::process::Stdio::inherit())
-            .output()
-            .context("adding toolchain")?;
-        anyhow::ensure!(
-            output_toolchain_add.status.success(),
-            "could not install required toolchain"
+        log::debug!("installing toolchain {channel}");
+        user_output!("Installing {message}\n")?;
+        Ok(())
+    };
+    let on_components_install = || {
+        let message = format!(
+            "components {REQUIRED_TOOLCHAIN_COMPONENTS:?} for toolchain {channel} with `rustup`"
         );
-    }
-
-    // Check for the required components
-    let output_component_list = std::process::Command::new("rustup")
-        .args(["component", "list", "--toolchain"])
-        .arg(channel)
-        .output()
-        .context("getting toolchain list")?;
-    anyhow::ensure!(
-        output_component_list.status.success(),
-        "could not list installed components"
-    );
-    let string_component_list = String::from_utf8_lossy(&output_component_list.stdout);
-    let required_components = ["rust-src", "rustc-dev", "llvm-tools"];
-    let installed_components = string_component_list.lines().collect::<Vec<_>>();
-    let all_components_installed = required_components.iter().all(|component| {
-        installed_components.iter().any(|installed_component| {
-            let is_component = installed_component.starts_with(component);
-            let is_installed = installed_component.ends_with("(installed)");
-            is_component && is_installed
-        })
-    });
-    if all_components_installed {
-        log::debug!("all required components are installed");
-    } else {
-        let message = "toolchain components [rust-src, rustc-dev, llvm-tools] with `rustup`";
         get_consent_for_toolchain_install(
             format!("Install {message}").as_ref(),
             skip_toolchain_install_consent,
         )?;
-        crate::user_output!("Installing {message}\n")?;
-
-        let output_component_add = std::process::Command::new("rustup")
-            .args(["component", "add", "--toolchain"])
-            .arg(channel)
-            .args(["rust-src", "rustc-dev", "llvm-tools"])
-            .stdout(std::process::Stdio::inherit())
-            .stderr(std::process::Stdio::inherit())
-            .output()
-            .context("adding rustup component")?;
-        anyhow::ensure!(
-            output_component_add.status.success(),
-            "could not install required components"
-        );
-    }
-
-    Ok(())
+        log::debug!("installing required components of toolchain {channel}");
+        user_output!("Installing {message}\n")?;
+        Ok(())
+    };
+    ensure_toolchain_installation(channel, on_toolchain_install, on_components_install)
 }
 
 /// Prompt user if they want to install a new Rust toolchain.
@@ -106,13 +49,13 @@ fn get_consent_for_toolchain_install(
     }
 
     if !std::io::stdout().is_tty() {
-        log::error!("Attempted to ask for consent when there's no TTY");
+        log::error!("attempted to ask for consent when there's no TTY");
         anyhow::bail!("no TTY detected, so can't ask for consent to install Rust toolchain")
     }
 
     log::debug!("asking for consent to install the required toolchain");
     crossterm::terminal::enable_raw_mode().context("enabling raw mode")?;
-    crate::user_output!("{prompt} [y/n]: ")?;
+    user_output!("{prompt} [y/n]: ")?;
     let mut input = crossterm::event::read().context("reading crossterm event")?;
 
     if let crossterm::event::Event::Key(crossterm::event::KeyEvent {

crates/rustc_codegen_spirv-cache/src/lib.rs

@@ -24,3 +24,4 @@ pub mod cache;
 pub mod metadata;
 pub mod spirv_source;
 pub mod target_specs;
+pub mod toolchain;

crates/rustc_codegen_spirv-cache/src/spirv_source.rs

@@ -264,7 +264,7 @@ pub fn rust_gpu_toolchain_channel(
     let path = rustc_codegen_spirv
         .manifest_path
         .parent()
-        .ok_or(RustGpuToolchainChannelError::PackageAtRoot)?;
+        .ok_or(RustGpuToolchainChannelError::ManifestAtRoot)?;
     let build_script = path.join("build.rs");
 
     log::debug!("Parsing `build.rs` at {build_script:?} for the used toolchain");
@@ -308,7 +308,7 @@ pub fn rust_gpu_toolchain_channel(
 
     let range = start..end;
     let Some(channel) = channel_line.get(range.clone()) else {
-        let err = RustGpuToolchainChannelError::InvalidRange {
+        let err = RustGpuToolchainChannelError::InvalidChannelSlice {
             range,
             channel_line: channel_line.to_owned(),
             build_script,
@@ -322,10 +322,10 @@ pub fn rust_gpu_toolchain_channel(
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
 pub enum RustGpuToolchainChannelError {
-    /// Package is located at the root of the file system
+    /// Manifest of the package is located at the root of the file system
     /// and cannot have a parent.
-    #[error("package located at root")]
-    PackageAtRoot,
+    #[error("package manifest was located at root")]
+    ManifestAtRoot,
     /// Build script file is not valid or does not exist.
     #[error("invalid build script {build_script}: {source}")]
     InvalidBuildScript {
@@ -356,7 +356,7 @@ pub enum RustGpuToolchainChannelError {
     },
     /// The range to slice the channel line is not valid.
     #[error("cannot slice line \"{channel_line}\" of {build_script:?} by range {range:?}")]
-    InvalidRange {
+    InvalidChannelSlice {
         /// The invalid range.
         range: Range<usize>,
         /// The line containing the channel information.