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,6 +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();
+<<<<<<< HEAD
                     let Some(ref mut state) = *guard else {
                         unreachable!()
                     };
@@ -96,6 +97,24 @@ impl Executor for ImmediateUnpacker {
                         state.item = Some(item);
                         Box::new(None.into_iter())
                     }
+=======
+                    match *guard { Some(ref mut state) => {
+                        if state.err.is_some() {
+                            let err = state.err.take().unwrap();
+                            item.result = err;
+                            item.finish = item
+                                .start
+                                .map(|s| Instant::now().saturating_duration_since(s));
+                            *guard = None;
+                            Box::new(Some(CompletedIo::Item(item)).into_iter())
+                        } else {
+                            state.item = Some(item);
+                            Box::new(None.into_iter())
+                        }
+                    } _ => {
+                        unreachable!();
+                    }}
+>>>>>>> 85c63ce1 (DON'T MERGE[ci skip]: demonstrate `if_let_rescope` auto migration)
                 };
             }
         };
@@ -180,26 +199,33 @@ impl IncrementalFileWriter {
         if (self.state.lock().unwrap()).is_none() {
             return false;
         }
+<<<<<<< HEAD
         let FileBuffer::Immediate(chunk) = chunk else {
+=======
+        let chunk = match chunk { FileBuffer::Immediate(v) => {
+            v
+        } _ => {
+>>>>>>> 85c63ce1 (DON'T MERGE[ci skip]: demonstrate `if_let_rescope` auto migration)
             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();
+<<<<<<< HEAD
         let Some(ref mut state) = *state else {
             unreachable!()
         };
@@ -219,5 +245,27 @@ impl IncrementalFileWriter {
         } else {
             Ok(false)
         }
+=======
+        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);
+                    drop(std::mem::take(&mut self.file));
+                    state.finished = true;
+                } else {
+                    trace_scoped!("write_segment", "name": self.path_display, "len": chunk.len());
+                    file.write_all(&chunk)?;
+
+                    state.completed_chunks.push(chunk.len());
+                }
+                Ok(true)
+            } _ => {
+                Ok(false)
+            }}
+        } _ => {
+            unreachable!();
+        }}
+>>>>>>> 85c63ce1 (DON'T MERGE[ci skip]: demonstrate `if_let_rescope` auto migration)
     }
 }

src/dist/component/package.rs

@@ -229,10 +229,18 @@ 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.
+<<<<<<< HEAD
                     match op.kind {
                         Kind::Directory => Ok(()),
                         _ => Err(e),
                     }
+=======
+                    match op.kind { Kind::Directory => {
+                        Ok(())
+                    } _ => {
+                        Err(e)
+                    }}
+>>>>>>> 85c63ce1 (DON'T MERGE[ci skip]: demonstrate `if_let_rescope` auto migration)
                 }
                 _ => Err(e),
             },
@@ -453,6 +461,7 @@ fn unpack_without_first_dir<R: Read>(
 
         let item = loop {
             // Create the full path to the entry if it does not exist already
+<<<<<<< HEAD
             let full_path = item.full_path.to_owned();
             let Some(parent) = full_path.parent() else {
                 // We should never see a path with no parent.
@@ -488,6 +497,43 @@ fn unpack_without_first_dir<R: Read>(
                     }
                 }
             }
+=======
+            match item.full_path.to_owned().parent() { Some(parent) => {
+                match directories.get_mut(parent) {
+                    None => {
+                        // Tar has item before containing directory
+                        // Complain about this so we can see if these exist.
+                        writeln!(
+                            process.stderr().lock(),
+                            "Unexpected: missing parent '{}' for '{}'",
+                            parent.display(),
+                            entry.path()?.display()
+                        )?;
+                        directories.insert(parent.to_owned(), DirStatus::Pending(vec![item]));
+                        item = Item::make_dir(parent.to_owned(), 0o755);
+                        // Check the parent's parent
+                        continue;
+                    }
+                    Some(DirStatus::Exists) => {
+                        break Some(item);
+                    }
+                    Some(DirStatus::Pending(pending)) => {
+                        // Parent dir is being made
+                        pending.push(item);
+                        if incremental_file_sender.is_none() {
+                            // take next item from tar
+                            continue 'entries;
+                        } else {
+                            // don't submit a new item for processing, but do be ready to feed data to the incremental file.
+                            break None;
+                        }
+                    }
+                }
+            } _ => {
+                // We should never see a path with no parent.
+                panic!();
+            }}
+>>>>>>> 85c63ce1 (DON'T MERGE[ci skip]: demonstrate `if_let_rescope` auto migration)
         };
 
         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));
             }