Don't search further back than installed nightly

This check is necessary for tests and other misbehaving repos where the
currently installed nightly may suddenly turn out to no longer be a
viable install candidate (e.g., because a component was retroactively
removed).

Author: jonhoo

src/dist/dist.rs

@@ -564,6 +564,7 @@ pub fn update_from_dist<'a>(
     profile: Option<Profile>,
     prefix: &InstallPrefix,
     force_update: bool,
+    old_date: Option<&str>,
 ) -> Result<Option<String>> {
     let fresh_install = !prefix.path().exists();
     let hash_exists = update_hash.map(Path::exists).unwrap_or(false);
@@ -582,6 +583,7 @@ pub fn update_from_dist<'a>(
         profile,
         prefix,
         force_update,
+        old_date,
     );
 
     // Don't leave behind an empty / broken installation directory
@@ -600,11 +602,29 @@ fn update_from_dist_<'a>(
     profile: Option<Profile>,
     prefix: &InstallPrefix,
     force_update: bool,
+    old_date: Option<&str>,
 ) -> Result<Option<String>> {
     let mut toolchain = toolchain.clone();
     let mut fetched = String::new();
     let mut first_err = None;
     let backtrack = toolchain.channel == "nightly" && toolchain.date.is_none();
+
+    // We never want to backtrack further back than the nightly that's already installed.
+    //
+    // If no nightly is installed, it makes no sense to backtrack beyond the first ever manifest,
+    // which is 2014-12-20 according to
+    // https://static.rust-lang.org/cargo-dist/index.html.
+    //
+    // We could arguably use the date of the first rustup release here, but that would break a
+    // bunch of the tests, which (inexplicably) use 2015-01-01 as their manifest dates.
+    let first_manifest = old_date
+        .map(|date| {
+            Utc.from_utc_date(
+                &NaiveDate::parse_from_str(date, "%Y-%m-%d").expect("Malformed manifest date"),
+            )
+        })
+        .unwrap_or_else(|| Utc.from_utc_date(&NaiveDate::from_ymd(2014, 12, 20)));
+
     loop {
         match try_update_from_dist_(
             download,
@@ -644,23 +664,28 @@ fn update_from_dist_<'a>(
                 // the components that the user currently has installed. Let's try the previous
                 // nightlies in reverse chronological order until we find a nightly that does,
                 // starting at one date earlier than the current manifest's date.
-                //
-                // NOTE: we don't need to explicitly check for the case where the next nightly to
-                // try is _older_ than the current nightly, since we know that the user's current
-                // nightlys supports the components they have installed, and thus would always
-                // terminate the search.
-                toolchain.date = Some(
-                    Utc.from_utc_date(
+                let try_next = Utc
+                    .from_utc_date(
                         &NaiveDate::parse_from_str(
                             toolchain.date.as_ref().unwrap_or(&fetched),
                             "%Y-%m-%d",
                         )
                         .expect("Malformed manifest date"),
                     )
-                    .pred()
-                    .format("%Y-%m-%d")
-                    .to_string(),
-                );
+                    .pred();
+
+                if try_next < first_manifest {
+                    // Wouldn't be an update if we go further back than the user's current nightly.
+                    if let Some(e) = first_err {
+                        break Err(e);
+                    } else {
+                        // In this case, all newer nightlies are missing, which means there are no
+                        // updates, so the user is already at the latest nightly.
+                        break Ok(None);
+                    }
+                }
+
+                toolchain.date = Some(try_next.format("%Y-%m-%d").to_string());
             }
         }
     }

src/install.rs

@@ -26,6 +26,8 @@ pub enum InstallMethod<'a> {
         bool,
         // toolchain already exists
         bool,
+        // currently installed date
+        Option<&'a str>,
     ),
 }
 
@@ -54,7 +56,15 @@ impl<'a> InstallMethod<'a> {
                 InstallMethod::tar_gz(src, path, &temp_cfg, notify_handler)?;
                 Ok(true)
             }
-            InstallMethod::Dist(toolchain, profile, update_hash, dl_cfg, force_update, exists) => {
+            InstallMethod::Dist(
+                toolchain,
+                profile,
+                update_hash,
+                dl_cfg,
+                force_update,
+                exists,
+                old_date,
+            ) => {
                 let prefix = &InstallPrefix::from(path.to_owned());
                 let maybe_new_hash = dist::update_from_dist(
                     dl_cfg,
@@ -63,6 +73,7 @@ impl<'a> InstallMethod<'a> {
                     if exists { None } else { profile },
                     prefix,
                     force_update,
+                    old_date,
                 )?;
 
                 if let Some(hash) = maybe_new_hash {

src/toolchain.rs

@@ -164,13 +164,15 @@ impl<'a> Toolchain<'a> {
 
     pub fn install_from_dist(&self, force_update: bool) -> Result<UpdateStatus> {
         let update_hash = self.update_hash()?;
+        let old_date = self.get_manifest().ok().and_then(|m| m.map(|m| m.date));
         self.install(InstallMethod::Dist(
             &self.desc()?,
             self.cfg.get_profile()?,
             update_hash.as_ref().map(|p| &**p),
             self.download_cfg(),
             force_update,
             self.exists(),
+            old_date.as_ref().map(|s| &**s),
         ))
     }
 
@@ -183,6 +185,7 @@ impl<'a> Toolchain<'a> {
             self.download_cfg(),
             false,
             false,
+            None,
         ))
     }
     pub fn is_custom(&self) -> bool {
@@ -470,7 +473,7 @@ impl<'a> Toolchain<'a> {
         })
     }
 
-    pub fn show_version(&self) -> Result<Option<String>> {
+    pub fn get_manifest(&self) -> Result<Option<Manifest>> {
         if !self.exists() {
             return Err(ErrorKind::ToolchainNotInstalled(self.name.to_owned()).into());
         }
@@ -481,7 +484,11 @@ impl<'a> Toolchain<'a> {
         let prefix = InstallPrefix::from(self.path.to_owned());
         let manifestation = Manifestation::open(prefix, toolchain.target.clone())?;
 
-        match manifestation.load_manifest()? {
+        manifestation.load_manifest()
+    }
+
+    pub fn show_version(&self) -> Result<Option<String>> {
+        match self.get_manifest()? {
             Some(manifest) => Ok(Some(manifest.get_rust_version()?.to_string())),
             None => Ok(None),
         }