Merge pull request #2264 from virome/component-unavailable-on-toolchain-message

Add error message to indicate that a missing command is not available…

Author: kinnison

src/errors.rs

@@ -308,6 +308,14 @@ error_chain! {
             description("toolchain does not contain binary")
             display("'{}' is not installed for the toolchain '{}'{}", bin, t, install_msg(bin, t, *is_default))
         }
+        BinaryProvidedByUnavailableComponent(component: String, bin: String, toolchain: String) {
+            description("binary is provided by a component which is not available in current toolchain")
+            display("the '{}' component which provides the command '{}' is not available for the '{}' toolchain", component, bin, toolchain)
+        }
+        BinaryNotProvidedByComponent(component: String, bin: String, toolchain: String) {
+            description("binary should be provided by component but isn't in current toolchain")
+            display("the '{}' binary, normally provided by the '{}' component, is not applicable to the '{}' toolchain", bin, component, toolchain)
+        }
         NeedMetadataUpgrade {
             description("rustup's metadata is out of date. run `rustup self upgrade-data`")
         }

src/lib.rs

@@ -41,8 +41,7 @@ fn component_for_bin(binary: &str) -> Option<&'static str> {
     match binary_prefix {
         "rustc" | "rustdoc" => Some("rustc"),
         "cargo" => Some("cargo"),
-        "rust-lldb" => Some("lldb-preview"),
-        "rust-gdb" => Some("gdb-preview"),
+        "rust-lldb" | "rust-gdb" => Some("rustc"), // These are not always available
         "rls" => Some("rls"),
         "cargo-clippy" => Some("clippy"),
         "clippy-driver" => Some("clippy"),

src/toolchain.rs

@@ -1,3 +1,4 @@
+use crate::component_for_bin;
 use crate::config::Cfg;
 use crate::dist::dist::TargetTriple;
 use crate::dist::dist::ToolchainDesc;
@@ -274,6 +275,38 @@ impl<'a> InstalledCommonToolchain<'a> {
                 .and_then(|s| s.parse().ok())
                 .unwrap_or(0);
             if recursion_count > env_var::RUST_RECURSION_COUNT_MAX - 1 {
+                let binary_lossy: String = binary.to_string_lossy().into();
+                if let Ok(distributable) = DistributableToolchain::new(self.0) {
+                    if let (Some(component_name), Ok(component_statuses), Ok(Some(manifest))) = (
+                        component_for_bin(&binary_lossy),
+                        distributable.list_components(),
+                        distributable.get_manifest(),
+                    ) {
+                        let component_status = component_statuses
+                            .iter()
+                            .find(|cs| cs.component.short_name(&manifest) == component_name)
+                            .expect(&format!(
+                                "component {} should be in the manifest",
+                                component_name
+                            ));
+                        if !component_status.available {
+                            return Err(ErrorKind::BinaryProvidedByUnavailableComponent(
+                                component_status.component.short_name(&manifest),
+                                binary_lossy,
+                                self.0.name.clone(),
+                            )
+                            .into());
+                        }
+                        if component_status.installed {
+                            return Err(ErrorKind::BinaryNotProvidedByComponent(
+                                component_status.component.short_name(&manifest),
+                                binary_lossy,
+                                self.0.name.clone(),
+                            )
+                            .into());
+                        }
+                    }
+                }
                 let defaults = self.0.cfg.get_default()?;
                 return Err(ErrorKind::BinaryNotFound(
                     binary.to_string_lossy().into(),

tests/cli-misc.rs

@@ -445,7 +445,30 @@ fn rls_exists_in_toolchain() {
 }
 
 #[test]
-fn rls_does_not_exist_in_toolchain() {
+fn run_rls_when_not_available_in_toolchain() {
+    clitools::setup(Scenario::UnavailableRls, &|config| {
+        set_current_dist_date(config, "2015-01-01");
+        expect_ok(config, &["rustup", "default", "nightly"]);
+        expect_err(
+            config,
+            &["rls", "--version"],
+            &format!(
+                "the 'rls' component which provides the command 'rls{}' is not available for the 'nightly-{}' toolchain",
+                EXE_SUFFIX,
+                this_host_triple(),
+            ),
+        );
+
+        set_current_dist_date(config, "2015-01-02");
+        expect_ok(config, &["rustup", "update", "--no-self-update"]);
+        expect_ok(config, &["rustup", "component", "add", "rls"]);
+
+        expect_ok(config, &["rls", "--version"]);
+    });
+}
+
+#[test]
+fn run_rls_when_not_installed() {
     setup(&|config| {
         expect_ok(config, &["rustup", "default", "stable"]);
         expect_err(
@@ -460,6 +483,23 @@ fn rls_does_not_exist_in_toolchain() {
     });
 }
 
+#[test]
+fn run_rust_lldb_when_not_in_toolchain() {
+    clitools::setup(Scenario::UnavailableRls, &|config| {
+        set_current_dist_date(config, "2015-01-01");
+        expect_ok(config, &["rustup", "default", "nightly"]);
+        expect_err(
+            config,
+            &["rust-lldb", "--version"],
+            &format!(
+                "the 'rust-lldb{}' binary, normally provided by the 'rustc' component, is not applicable to the 'nightly-{}' toolchain",
+                EXE_SUFFIX,
+                this_host_triple(),
+            ),
+        );
+    });
+}
+
 #[test]
 fn rename_rls_before() {
     clitools::setup(Scenario::ArchivesV2, &|config| {

tests/mock/clitools.rs

@@ -147,12 +147,14 @@ pub fn setup(s: Scenario, f: &dyn Fn(&mut Config)) {
     let rustc_path = config.exedir.join(format!("rustc{}", EXE_SUFFIX));
     let cargo_path = config.exedir.join(format!("cargo{}", EXE_SUFFIX));
     let rls_path = config.exedir.join(format!("rls{}", EXE_SUFFIX));
+    let rust_lldb_path = config.exedir.join(format!("rust-lldb{}", EXE_SUFFIX));
 
     copy_binary(&build_path, &rustup_path).unwrap();
     hard_link(&rustup_path, setup_path).unwrap();
     hard_link(&rustup_path, rustc_path).unwrap();
     hard_link(&rustup_path, cargo_path).unwrap();
     hard_link(&rustup_path, rls_path).unwrap();
+    hard_link(&rustup_path, rust_lldb_path).unwrap();
 
     // Make sure the host triple matches the build triple. Otherwise testing a 32-bit build of
     // rustup on a 64-bit machine will fail, because the tests do not have the host detection