Decouple install toolchain handling, add error types for it

tuguzT · tuguzT · commit 8c247a407b30 · 2025-09-27T23:41:27.000+03:00
diff --git a/crates/cargo-gpu-cache/src/install_toolchain.rs b/crates/cargo-gpu-cache/src/install_toolchain.rs
@@ -1,56 +1,35 @@
 //! toolchain installation logic
 
+use std::process::{Command, Stdio};
+
 use anyhow::Context as _;
 use crossterm::tty::IsTty as _;
+use rustc_codegen_spirv_cache::toolchain::is_toolchain_installed;
 
-/// 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
-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"])
+use crate::user_output;
+
+/// Installs the given toolchain using `rustup`.
+pub fn install_toolchain(channel: &str) -> anyhow::Result<()> {
+    let output_toolchain_add = Command::new("rustup")
+        .args(["toolchain", "add"])
+        .arg(channel)
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
         .output()
-        .context("running rustup command")?;
+        .context("adding toolchain")?;
     anyhow::ensure!(
-        output_toolchain_list.status.success(),
-        "could not list installed toolchains"
+        output_toolchain_add.status.success(),
+        "could not install required toolchain"
     );
-    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 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"
-        );
-    }
+    Ok(())
+}
 
-    // Check for the required components
-    let output_component_list = std::process::Command::new("rustup")
+/// Components which are required to be installed for a toolchain to be usable with `rust-gpu`.
+pub const REQUIRED_TOOLCHAIN_COMPONENTS: [&str; 3] = ["rust-src", "rustc-dev", "llvm-tools"];
+
+/// Checks if all the required components of the given toolchain are installed using `rustup`.
+pub fn all_required_toolchain_components_installed(channel: &str) -> anyhow::Result<bool> {
+    let output_component_list = Command::new("rustup")
         .args(["component", "list", "--toolchain"])
         .arg(channel)
         .output()
@@ -59,38 +38,72 @@ pub fn ensure_toolchain_and_components_exist(
         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| {
+    let all_components_installed = REQUIRED_TOOLCHAIN_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");
+    Ok(all_components_installed)
+}
+
+/// Installs all the required components for the given toolchain using `rustup`.
+pub fn install_required_toolchain_components(channel: &str) -> anyhow::Result<()> {
+    let output_component_add = Command::new("rustup")
+        .args(["component", "add", "--toolchain"])
+        .arg(channel)
+        .args(REQUIRED_TOOLCHAIN_COMPONENTS)
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .output()
+        .context("adding rustup component")?;
+    anyhow::ensure!(
+        output_component_add.status.success(),
+        "could not install required components"
+    );
+    Ok(())
+}
+
+/// 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
+pub fn ensure_toolchain_and_components_exist(
+    channel: &str,
+    skip_toolchain_install_consent: bool,
+) -> anyhow::Result<()> {
+    // Check for the required toolchain
+    if is_toolchain_installed(channel)? {
+        log::debug!("toolchain {channel} is already installed");
     } else {
-        let message = "toolchain components [rust-src, rustc-dev, llvm-tools] with `rustup`";
+        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_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"
+        user_output!("Installing {message}\n")?;
+        install_toolchain(channel)?;
+    }
+
+    // Check for the required components
+    if all_required_toolchain_components_installed(channel)? {
+        log::debug!("all required components of toolchain {channel} are installed");
+    } else {
+        let message = format!(
+            "components {REQUIRED_TOOLCHAIN_COMPONENTS:?} for toolchain {channel} with `rustup`"
         );
+        get_consent_for_toolchain_install(
+            format!("Install {message}").as_ref(),
+            skip_toolchain_install_consent,
+        )?;
+        user_output!("Installing {message}\n")?;
+        install_required_toolchain_components(channel)?;
     }
 
     Ok(())
@@ -112,7 +125,7 @@ fn get_consent_for_toolchain_install(
 
     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 {
diff --git a/crates/rustc_codegen_spirv-cache/src/lib.rs b/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;
diff --git a/crates/rustc_codegen_spirv-cache/src/toolchain.rs b/crates/rustc_codegen_spirv-cache/src/toolchain.rs
@@ -0,0 +1,90 @@
+//! This module deals with an installation of Rust toolchain required by `rust-gpu`
+//! (and its components).
+
+use std::{
+    io,
+    process::{Command, Output},
+};
+
+/// Checks if the given toolchain is installed using `rustup`.
+///
+/// # Errors
+///
+/// Returns an error if any error occurs while using `rustup`.
+#[inline]
+pub fn is_toolchain_installed(channel: &str) -> Result<bool, RustupCallError> {
+    let mut command = Command::new("rustup");
+    command.args(["toolchain", "list"]);
+
+    let output = match command.output() {
+        Ok(output) => output,
+        Err(source) => return Err(RustupCallError::io(command, source)),
+    };
+    if !output.status.success() {
+        return Err(RustupCallError::command_fail(command, output));
+    }
+
+    let toolchain_list = String::from_utf8_lossy(&output.stdout);
+    let installed = toolchain_list
+        .split_whitespace()
+        .any(|toolchain| toolchain.starts_with(channel));
+    Ok(installed)
+}
+
+/// An error indicating failure while using `rustup`.
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum RustupCallError {
+    /// IO error occurred while calling some `rustup` command.
+    #[error("IO error occurred while calling `{command:?}`: {source}")]
+    Io {
+        /// The command which was called.
+        command: Box<Command>,
+        /// Source of the error.
+        source: io::Error,
+    },
+    /// Result of calling some `rustup` command was not successful.
+    #[error("calling `{command:?}` was not successful")]
+    CommandFail {
+        /// The command which was called.
+        command: Box<Command>,
+        /// The output of called command.
+        output: Output,
+    },
+}
+
+impl RustupCallError {
+    /// Creates [`Io`](RustupCallError::Io) variant from given arguments.
+    fn io(command: impl Into<Box<Command>>, source: io::Error) -> Self {
+        Self::Io {
+            command: command.into(),
+            source,
+        }
+    }
+
+    /// Creates [`CommandFail`](RustupCallError::CommandFail) variant from given arguments.
+    fn command_fail(command: impl Into<Box<Command>>, output: Output) -> Self {
+        Self::CommandFail {
+            command: command.into(),
+            output,
+        }
+    }
+
+    /// Returns the command which was called.
+    #[inline]
+    #[expect(clippy::must_use_candidate, reason = "returns a reference")]
+    pub fn command(&self) -> &Command {
+        match self {
+            Self::Io { command, .. } | Self::CommandFail { command, .. } => command.as_ref(),
+        }
+    }
+
+    /// Converts self into the command which was called.
+    #[inline]
+    #[must_use]
+    pub fn into_command(self) -> Command {
+        match self {
+            Self::Io { command, .. } | Self::CommandFail { command, .. } => *command,
+        }
+    }
+}
