DON'T MERGE[ci skip]: demonstrate if_let_rescope auto migration

Author: rami3l

Cargo.toml

@@ -155,7 +155,8 @@ url = "2.4"
 walkdir = "2"
 
 [workspace.lints.rust]
-rust_2018_idioms = "deny"
+rust_2018_idioms = { level = "deny", priority = -1 }
+if_let_rescope = { level = "warn", priority = -2 }
 
 [workspace.lints.clippy]
 # `dbg!()` and `todo!()` clearly shouldn't make it to production:

src/cli/common.rs

@@ -417,13 +417,12 @@ pub(crate) fn list_toolchains(
     } else {
         let default_toolchain_name = cfg.get_default()?;
         let active_toolchain_name: Option<ToolchainName> =
-            if let Ok(Some((LocalToolchainName::Named(toolchain), _reason))) =
-                cfg.find_active_toolchain()
-            {
+            match cfg.find_active_toolchain()
+            { Ok(Some((LocalToolchainName::Named(toolchain), _reason))) => {
                 Some(toolchain)
-            } else {
+            } _ => {
                 None
-            };
+            }};
 
         for toolchain in toolchains {
             let is_default_toolchain = default_toolchain_name.as_ref() == Some(&toolchain);

src/cli/rustup_mode.rs

@@ -727,7 +727,7 @@ async fn default_(
 ) -> Result<utils::ExitCode> {
     common::warn_if_host_is_emulated(cfg.process);
 
-    if let Some(toolchain) = toolchain {
+    match toolchain { Some(toolchain) => {
         match toolchain.to_owned() {
             MaybeResolvableToolchainName::None => {
                 cfg.set_default(None)?;
@@ -756,12 +756,12 @@ async fn default_(
                 info!("note that the toolchain '{toolchain}' is currently in use ({reason})");
             }
         }
-    } else {
+    } _ => {
         let default_toolchain = cfg
             .get_default()?
             .ok_or_else(|| anyhow!("no default toolchain is configured"))?;
         writeln!(cfg.process.stdout().lock(), "{default_toolchain} (default)")?;
-    }
+    }}
 
     Ok(utils::ExitCode(0))
 }
@@ -961,13 +961,12 @@ fn show(cfg: &Cfg<'_>, verbose: bool) -> Result<utils::ExitCode> {
 
     let installed_toolchains = cfg.list_toolchains()?;
     let active_toolchain_and_reason: Option<(ToolchainName, ActiveReason)> =
-        if let Ok(Some((LocalToolchainName::Named(toolchain_name), reason))) =
-            cfg.find_active_toolchain()
-        {
+        match cfg.find_active_toolchain()
+        { Ok(Some((LocalToolchainName::Named(toolchain_name), reason))) => {
             Some((toolchain_name, reason))
-        } else {
+        } _ => {
             None
-        };
+        }};
 
     let (active_toolchain_name, _active_reason) = active_toolchain_and_reason
         .as_ref()

src/config.rs

@@ -518,42 +518,34 @@ impl<'a> Cfg<'a> {
         &self,
     ) -> Result<Option<(LocalToolchainName, ActiveReason)>> {
         Ok(
-            if let Some((override_config, reason)) = self.find_override_config()? {
+            match self.find_override_config()? { Some((override_config, reason)) => {
                 Some((override_config.into_local_toolchain_name(), reason))
-            } else {
+            } _ => {
                 self.get_default()?
                     .map(|x| (x.into(), ActiveReason::Default))
-            },
+            }},
         )
     }
 
     fn find_override_config(&self) -> Result<Option<(OverrideCfg, ActiveReason)>> {
         let override_config: Option<(OverrideCfg, ActiveReason)> =
             // First check +toolchain override from the command line
-            if let Some(ref name) = self.toolchain_override {
+            match self.toolchain_override { Some(ref name) => {
                 let override_config = name.resolve(&self.get_default_host_triple()?)?.into();
                 Some((override_config, ActiveReason::CommandLine))
-            }
-            // Then check the RUSTUP_TOOLCHAIN environment variable
-            else if let Some(ref name) = self.env_override {
+            } _ => { match self.env_override { Some(ref name) => {
                 // Because path based toolchain files exist, this has to support
                 // custom, distributable, and absolute path toolchains otherwise
                 // rustup's export of a RUSTUP_TOOLCHAIN when running a process will
                 // error when a nested rustup invocation occurs
                 Some((name.clone().into(), ActiveReason::Environment))
-            }
-            // Then walk up the directory tree from 'path' looking for either the
-            // directory in the override database, or a `rust-toolchain{.toml}` file,
-            // in that order.
-            else if let Some((override_cfg, active_reason)) = self.settings_file.with(|s| {
+            } _ => { match self.settings_file.with(|s| {
                     self.find_override_from_dir_walk(&self.current_dir, s)
-                })? {
+                })? { Some((override_cfg, active_reason)) => {
                 Some((override_cfg, active_reason))
-            }
-            // Otherwise, there is no override.
-            else {
+            } _ => {
                 None
-            };
+            }}}}}};
 
         Ok(override_config)
     }
@@ -753,15 +745,15 @@ impl<'a> Cfg<'a> {
         force_non_host: bool,
         verbose: bool,
     ) -> Result<(LocalToolchainName, ActiveReason)> {
-        if let Some((override_config, reason)) = self.find_override_config()? {
+        match self.find_override_config()? { Some((override_config, reason)) => {
             let toolchain = override_config.clone().into_local_toolchain_name();
-            if let OverrideCfg::Official {
+            match override_config
+            { OverrideCfg::Official {
                 toolchain,
                 components,
                 targets,
                 profile,
-            } = override_config
-            {
+            } => {
                 self.ensure_installed(
                     &toolchain,
                     components,
@@ -771,22 +763,22 @@ impl<'a> Cfg<'a> {
                     verbose,
                 )
                 .await?;
-            } else {
+            } _ => {
                 Toolchain::with_reason(self, toolchain.clone(), &reason)?;
-            }
+            }}
             Ok((toolchain, reason))
-        } else if let Some(toolchain) = self.get_default()? {
+        } _ => { match self.get_default()? { Some(toolchain) => {
             let reason = ActiveReason::Default;
-            if let ToolchainName::Official(desc) = &toolchain {
+            match &toolchain { ToolchainName::Official(desc) => {
                 self.ensure_installed(desc, vec![], vec![], None, force_non_host, verbose)
                     .await?;
-            } else {
+            } _ => {
                 Toolchain::with_reason(self, toolchain.clone().into(), &reason)?;
-            }
+            }}
             Ok((toolchain.into(), reason))
-        } else {
+        } _ => {
             Err(no_toolchain_error(self.process))
-        }
+        }}}}
     }
 
     // Returns a Toolchain matching the given ToolchainDesc, installing it and
@@ -894,11 +886,11 @@ impl<'a> Cfg<'a> {
         self.list_toolchains()?
             .into_iter()
             .filter_map(|t| {
-                if let ToolchainName::Official(desc) = t {
+                match t { ToolchainName::Official(desc) => {
                     Some(desc)
-                } else {
+                } _ => {
                     None
-                }
+                }}
             })
             .filter(ToolchainDesc::is_tracking)
             .map(|n| {

src/diskio/immediate.rs

@@ -38,7 +38,7 @@ impl ImmediateUnpacker {
     fn deque(&self) -> Box<dyn Iterator<Item = CompletedIo>> {
         let mut guard = self.incremental_state.lock().unwrap();
         // incremental file in progress
-        if let Some(ref mut state) = *guard {
+        match *guard { Some(ref mut state) => {
             // Case 1: pending errors
             if state.finished {
                 let mut item = state.item.take().unwrap();
@@ -59,9 +59,9 @@ impl ImmediateUnpacker {
                 completed_chunks.append(&mut state.completed_chunks);
                 Box::new(completed_chunks.into_iter().map(CompletedIo::Chunk))
             }
-        } else {
+        } _ => {
             Box::new(None.into_iter())
-        }
+        }}
     }
 }
 
@@ -81,7 +81,7 @@ impl Executor for ImmediateUnpacker {
                     // If there is a pending error, return it, otherwise stash the
                     // Item for eventual return when the file is finished.
                     let mut guard = self.incremental_state.lock().unwrap();
-                    if let Some(ref mut state) = *guard {
+                    match *guard { Some(ref mut state) => {
                         if state.err.is_some() {
                             let err = state.err.take().unwrap();
                             item.result = err;
@@ -94,9 +94,9 @@ impl Executor for ImmediateUnpacker {
                             state.item = Some(item);
                             Box::new(None.into_iter())
                         }
-                    } else {
+                    } _ => {
                         unreachable!();
-                    }
+                    }}
                 };
             }
         };
@@ -181,30 +181,30 @@ impl IncrementalFileWriter {
         if (self.state.lock().unwrap()).is_none() {
             return false;
         }
-        let chunk = if let FileBuffer::Immediate(v) = chunk {
+        let chunk = match chunk { FileBuffer::Immediate(v) => {
             v
-        } else {
+        } _ => {
             unreachable!()
-        };
+        }};
         match self.write(chunk) {
             Ok(v) => v,
             Err(e) => {
                 let mut state = self.state.lock().unwrap();
-                if let Some(ref mut state) = *state {
+                match *state { Some(ref mut state) => {
                     state.err.replace(Err(e));
                     state.finished = true;
                     false
-                } else {
+                } _ => {
                     false
-                }
+                }}
             }
         }
     }
 
     fn write(&mut self, chunk: Vec<u8>) -> std::result::Result<bool, io::Error> {
         let mut state = self.state.lock().unwrap();
-        if let Some(ref mut state) = *state {
-            if let Some(ref mut file) = self.file.as_mut() {
+        match *state { Some(ref mut state) => {
+            match self.file.as_mut() { Some(ref mut file) => {
                 // Length 0 vector is used for clean EOF signalling.
                 if chunk.is_empty() {
                     trace_scoped!("close", "name:": self.path_display);
@@ -217,11 +217,11 @@ impl IncrementalFileWriter {
                     state.completed_chunks.push(chunk.len());
                 }
                 Ok(true)
-            } else {
+            } _ => {
                 Ok(false)
-            }
-        } else {
+            }}
+        } _ => {
             unreachable!();
-        }
+        }}
     }
 }

src/dist/component/package.rs

@@ -229,11 +229,11 @@ fn filter_result(op: &mut CompletedIo) -> io::Result<()> {
                     // mkdir of e.g. ~/.rustup already existing is just fine;
                     // for others it would be better to know whether it is
                     // expected to exist or not -so put a flag in the state.
-                    if let Kind::Directory = op.kind {
+                    match op.kind { Kind::Directory => {
                         Ok(())
-                    } else {
+                    } _ => {
                         Err(e)
-                    }
+                    }}
                 }
                 _ => Err(e),
             },
@@ -454,7 +454,7 @@ fn unpack_without_first_dir<R: Read>(
 
         let item = loop {
             // Create the full path to the entry if it does not exist already
-            if let Some(parent) = item.full_path.to_owned().parent() {
+            match item.full_path.to_owned().parent() { Some(parent) => {
                 match directories.get_mut(parent) {
                     None => {
                         // Tar has item before containing directory
@@ -485,10 +485,10 @@ fn unpack_without_first_dir<R: Read>(
                         }
                     }
                 }
-            } else {
+            } _ => {
                 // We should never see a path with no parent.
                 panic!();
-            }
+            }}
         };
 
         if let Some(item) = item {

src/dist/download.rs

@@ -162,14 +162,14 @@ impl<'a> DownloadCfg<'a> {
 
         if let Some(hash_file) = update_hash {
             if utils::is_file(hash_file) {
-                if let Ok(contents) = utils::read_file("update hash", hash_file) {
+                match utils::read_file("update hash", hash_file) { Ok(contents) => {
                     if contents == partial_hash {
                         // Skip download, update hash matches
                         return Ok(None);
                     }
-                } else {
+                } _ => {
                     (self.notify_handler)(Notification::CantReadUpdateHash(hash_file));
-                }
+                }}
             } else {
                 (self.notify_handler)(Notification::NoUpdateHash(hash_file));
             }

src/dist/manifestation.rs

@@ -369,15 +369,15 @@ impl Manifestation {
         // component name plus the target triple.
         let name = component.name_in_manifest();
         let short_name = component.short_name_in_manifest();
-        if let Some(c) = self.installation.find(&name)? {
+        match self.installation.find(&name)? { Some(c) => {
             tx = c.uninstall(tx, process)?;
-        } else if let Some(c) = self.installation.find(short_name)? {
+        } _ => { match self.installation.find(short_name)? { Some(c) => {
             tx = c.uninstall(tx, process)?;
-        } else {
+        } _ => {
             notify_handler(Notification::MissingInstalledComponent(
                 &component.short_name(manifest),
             ));
-        }
+        }}}}
 
         Ok(tx)
     }

src/dist/mod.rs

@@ -335,11 +335,11 @@ impl FromStr for ParsedToolchainDesc {
             }
         });
 
-        if let Some(d) = d {
+        match d { Some(d) => {
             Ok(d)
-        } else {
+        } _ => {
             Err(RustupError::InvalidToolchainName(desc.to_string()).into())
-        }
+        }}
     }
 }
 
@@ -975,13 +975,13 @@ pub(crate) async fn update_from_dist(
 
         if try_next < last_manifest {
             // Wouldn't be an update if we go further back than the user's current nightly.
-            if let Some(e) = first_err {
+            match first_err { Some(e) => {
                 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());