style: partially migrate away from if-let

Following
<https://users.rust-lang.org/t/rust-2024-compatibility-lint-and-the-if-let-temporary-scope/125969/5>,
I have manually audited all `if_let_rescope` cases and found out that
certain existing cases can be rewritten to make it clearer semantically.
So these migrations have been made in advance so that the only cases of
`if-let` remaining are false positives of this lint.

The crux of determining false positives here is that, according to
<rust-lang/rust#133167>, `if let Some()`
and other similar cases where the `else` drop is not significant are
not affected by the Edition change.

Author: rami3l

src/diskio/immediate.rs

@@ -81,21 +81,20 @@ 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 {
-                        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())
-                        }
+                    let Some(ref mut state) = *guard else {
+                        unreachable!()
+                    };
+                    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 {
-                        unreachable!();
+                        state.item = Some(item);
+                        Box::new(None.into_iter())
                     }
                 };
             }
@@ -181,9 +180,7 @@ impl IncrementalFileWriter {
         if (self.state.lock().unwrap()).is_none() {
             return false;
         }
-        let chunk = if let FileBuffer::Immediate(v) = chunk {
-            v
-        } else {
+        let FileBuffer::Immediate(chunk) = chunk else {
             unreachable!()
         };
         match self.write(chunk) {
@@ -203,25 +200,23 @@ impl IncrementalFileWriter {
 
     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() {
-                // 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)
-            } else {
-                Ok(false)
-            }
+        let Some(ref mut state) = *state else {
+            unreachable!()
+        };
+        let Some(ref mut file) = self.file.as_mut() else {
+            return Ok(false);
+        };
+        // 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 {
-            unreachable!();
+            trace_scoped!("write_segment", "name": self.path_display, "len": chunk.len());
+            file.write_all(&chunk)?;
+
+            state.completed_chunks.push(chunk.len());
         }
+        Ok(true)
     }
 }

src/dist/component/package.rs

@@ -229,10 +229,9 @@ 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 {
-                        Ok(())
-                    } else {
-                        Err(e)
+                    match op.kind {
+                        Kind::Directory => Ok(()),
+                        _ => Err(e),
                     }
                 }
                 _ => Err(e),
@@ -454,40 +453,40 @@ 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 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;
-                        }
+            let full_path = item.full_path.to_owned();
+            let Some(parent) = full_path.parent() else {
+                // We should never see a path with no parent.
+                unreachable!()
+            };
+            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;
                     }
                 }
-            } else {
-                // We should never see a path with no parent.
-                panic!();
             }
         };
 

src/dist/mod.rs

@@ -335,10 +335,9 @@ impl FromStr for ParsedToolchainDesc {
             }
         });
 
-        if let Some(d) = d {
-            Ok(d)
-        } else {
-            Err(RustupError::InvalidToolchainName(desc.to_string()).into())
+        match d {
+            Some(d) => Ok(d),
+            None => Err(RustupError::InvalidToolchainName(desc.to_string()).into()),
         }
     }
 }