style: partially migrate if-let to match or let-else

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 here in advance so what remains is
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,24 @@ 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)
+        let Some(ref mut state) = *state else {
+            unreachable!()
+        };
+        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 {
-                Ok(false)
+                trace_scoped!("write_segment", "name": self.path_display, "len": chunk.len());
+                file.write_all(&chunk)?;
+
+                state.completed_chunks.push(chunk.len());
             }
+            Ok(true)
         } else {
-            unreachable!();
+            Ok(false)
         }
     }
 }

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,11 +335,7 @@ impl FromStr for ParsedToolchainDesc {
             }
         });
 
-        if let Some(d) = d {
-            Ok(d)
-        } else {
-            Err(RustupError::InvalidToolchainName(desc.to_string()).into())
-        }
+        d.ok_or_else(|| RustupError::InvalidToolchainName(desc.to_string()).into())
     }
 }