Remove is_valid_install_method

This is now enforced by the type system rather than asserts.

Author: rbtcollins

src/install.rs

@@ -9,15 +9,15 @@ use crate::dist::temp;
 use crate::dist::Notification;
 use crate::errors::Result;
 use crate::notifications::Notification as RootNotification;
-use crate::toolchain::{Toolchain, UpdateStatus};
+use crate::toolchain::{CustomToolchain, DistributableToolchain, Toolchain, UpdateStatus};
 use crate::utils::utils;
 use std::path::Path;
 
 #[derive(Copy, Clone)]
 pub enum InstallMethod<'a> {
-    Copy(&'a Path),
-    Link(&'a Path),
-    Installer(&'a Path, &'a temp::Cfg),
+    Copy(&'a Path, &'a CustomToolchain<'a>),
+    Link(&'a Path, &'a CustomToolchain<'a>),
+    Installer(&'a Path, &'a temp::Cfg, &'a CustomToolchain<'a>),
     // bool is whether to force an update
     Dist(
         &'a dist::ToolchainDesc,
@@ -36,13 +36,13 @@ pub enum InstallMethod<'a> {
         &'a [&'a str],
         // Extra targets to install from dist
         &'a [&'a str],
+        &'a DistributableToolchain<'a>,
     ),
 }
 
 impl<'a> InstallMethod<'a> {
     // Install a toolchain
     pub fn install(&self, toolchain: &Toolchain<'a>) -> Result<UpdateStatus> {
-        assert!(toolchain.is_valid_install_method(*self));
         let previous_version = if toolchain.exists() {
             Some(toolchain.rustc_version())
         } else {
@@ -94,15 +94,15 @@ impl<'a> InstallMethod<'a> {
         }
 
         match self {
-            InstallMethod::Copy(src) => {
+            InstallMethod::Copy(src, ..) => {
                 utils::copy_dir(src, path, notify_handler)?;
                 Ok(true)
             }
-            InstallMethod::Link(src) => {
+            InstallMethod::Link(src, ..) => {
                 utils::symlink_dir(src, &path, notify_handler)?;
                 Ok(true)
             }
-            InstallMethod::Installer(src, temp_cfg) => {
+            InstallMethod::Installer(src, temp_cfg, ..) => {
                 InstallMethod::tar_gz(src, path, &temp_cfg, notify_handler)?;
                 Ok(true)
             }
@@ -117,6 +117,7 @@ impl<'a> InstallMethod<'a> {
                 old_date,
                 components,
                 targets,
+                ..,
             ) => {
                 let prefix = &InstallPrefix::from(path.to_owned());
                 let maybe_new_hash = dist::update_from_dist(

src/toolchain.rs

@@ -139,17 +139,6 @@ impl<'a> Toolchain<'a> {
         Ok(())
     }
 
-    // Custom and Distributable. Installed and not installed (because of install_from_dist_if_not_installed) Goes away?
-    // Or perhaps a trait.
-    pub fn is_valid_install_method(&self, install_method: InstallMethod<'_>) -> bool {
-        match install_method {
-            InstallMethod::Copy(_) | InstallMethod::Link(_) | InstallMethod::Installer(..) => {
-                self.is_custom()
-            }
-            InstallMethod::Dist(..) => !self.is_custom(),
-        }
-    }
-
     // XXX: Move to Config with a notify handler parameter
     fn download_cfg(&self) -> DownloadCfg<'_> {
         DownloadCfg {
@@ -186,6 +175,7 @@ impl<'a> Toolchain<'a> {
     pub fn install_from_installers(&self, installers: &[&OsStr]) -> Result<()> {
         self.ensure_custom()?;
 
+        let custom = CustomToolchain::new(&self)?;
         self.remove()?;
 
         // FIXME: This should do all downloads first, then do
@@ -214,15 +204,17 @@ impl<'a> Toolchain<'a> {
                 utils::download_file(&url, &local_installer, None, &|n| {
                     (self.cfg.notify_handler)(n.into())
                 })?;
-                InstallMethod::Installer(&local_installer, &self.cfg.temp_cfg).install(&self)?;
+                InstallMethod::Installer(&local_installer, &self.cfg.temp_cfg, &custom)
+                    .install(&self)?;
             } else {
                 // If installer is a filename
 
                 // No need to download
                 let local_installer = Path::new(installer);
 
                 // Install from file
-                InstallMethod::Installer(&local_installer, &self.cfg.temp_cfg).install(&self)?;
+                InstallMethod::Installer(&local_installer, &self.cfg.temp_cfg, &custom)
+                    .install(&self)?;
             }
         }
 
@@ -232,6 +224,7 @@ impl<'a> Toolchain<'a> {
     // Custom only. Not installed only.
     pub fn install_from_dir(&self, src: &Path, link: bool) -> Result<()> {
         self.ensure_custom()?;
+        let custom = CustomToolchain::new(&self)?;
 
         let mut pathbuf = PathBuf::from(src);
 
@@ -244,9 +237,9 @@ impl<'a> Toolchain<'a> {
         utils::assert_is_file(&pathbuf)?;
 
         if link {
-            InstallMethod::Link(&utils::to_absolute(src)?).install(&self)?;
+            InstallMethod::Link(&utils::to_absolute(src)?, &custom).install(&self)?;
         } else {
-            InstallMethod::Copy(src).install(&self)?;
+            InstallMethod::Copy(src, &custom).install(&self)?;
         }
 
         Ok(())
@@ -731,6 +724,7 @@ impl<'a> DistributableToolchain<'a> {
             old_date.as_ref().map(|s| &**s),
             components,
             targets,
+            &self,
         )
         .install(&self.0)
     }
@@ -751,6 +745,7 @@ impl<'a> DistributableToolchain<'a> {
                 None,
                 &[],
                 &[],
+                &self,
             )
             .install(&self.0)?)
         } else {