chore: fix new clippy warnings

Author: rami3l

src/cli/rustup_mode.rs

@@ -49,10 +49,10 @@ fn handle_epipe(res: Result<utils::ExitCode>) -> Result<utils::ExitCode> {
     match res {
         Err(e) => {
             let root = e.root_cause();
-            if let Some(io_err) = root.downcast_ref::<std::io::Error>() {
-                if io_err.kind() == std::io::ErrorKind::BrokenPipe {
-                    return Ok(utils::ExitCode(0));
-                }
+            if let Some(io_err) = root.downcast_ref::<std::io::Error>()
+                && io_err.kind() == std::io::ErrorKind::BrokenPipe
+            {
+                return Ok(utils::ExitCode(0));
             }
             Err(e)
         }
@@ -774,10 +774,10 @@ async fn default_(
             }
         };
 
-        if let Some((toolchain, reason)) = cfg.active_toolchain()? {
-            if !matches!(reason, ActiveReason::Default) {
-                info!("note that the toolchain '{toolchain}' is currently in use ({reason})");
-            }
+        if let Some((toolchain, reason)) = cfg.active_toolchain()?
+            && !matches!(reason, ActiveReason::Default)
+        {
+            info!("note that the toolchain '{toolchain}' is currently in use ({reason})");
         }
     } else {
         let default_toolchain = cfg
@@ -1631,8 +1631,8 @@ async fn doc(
 ) -> Result<utils::ExitCode> {
     let toolchain = cfg.toolchain_from_partial(toolchain).await?;
 
-    if let Ok(distributable) = DistributableToolchain::try_from(&toolchain) {
-        if let [_] = distributable
+    if let Ok(distributable) = DistributableToolchain::try_from(&toolchain)
+        && let [_] = distributable
             .components()?
             .into_iter()
             .filter(|cstatus| {
@@ -1641,19 +1641,18 @@ async fn doc(
             .take(1)
             .collect::<Vec<ComponentStatus>>()
             .as_slice()
-        {
-            info!(
-                "`rust-docs` not installed in toolchain `{}`",
-                distributable.desc()
-            );
-            info!(
-                "To install, try `rustup component add --toolchain {} rust-docs`",
-                distributable.desc()
-            );
-            return Err(anyhow!(
-                "unable to view documentation which is not installed"
-            ));
-        }
+    {
+        info!(
+            "`rust-docs` not installed in toolchain `{}`",
+            distributable.desc()
+        );
+        info!(
+            "To install, try `rustup component add --toolchain {} rust-docs`",
+            distributable.desc()
+        );
+        return Err(anyhow!(
+            "unable to view documentation which is not installed"
+        ));
     };
 
     let (doc_path, fragment) = match (topic, doc_page.name()) {

src/config.rs

@@ -659,17 +659,15 @@ impl<'a> Cfg<'a> {
                     let default_host_triple = get_default_host_triple(settings, self.process);
                     // Do not permit architecture/os selection in channels as
                     // these are host specific and toolchain files are portable.
-                    if let ResolvableToolchainName::Official(ref name) = toolchain_name {
-                        if name.has_triple() {
-                            // Permit fully qualified names IFF the toolchain is installed. TODO(robertc): consider
-                            // disabling this and backing out https://github.com/rust-lang/rustup/pull/2141 (but provide
-                            // the base name in the error to help users)
-                            let resolved_name = &ToolchainName::try_from(toolchain_name_str)?;
-                            if !self.list_toolchains()?.iter().any(|s| s == resolved_name) {
-                                return Err(anyhow!(format!(
-                                    "target triple in channel name '{name}'"
-                                )));
-                            }
+                    if let ResolvableToolchainName::Official(ref name) = toolchain_name
+                        && name.has_triple()
+                    {
+                        // Permit fully qualified names IFF the toolchain is installed. TODO(robertc): consider
+                        // disabling this and backing out https://github.com/rust-lang/rustup/pull/2141 (but provide
+                        // the base name in the error to help users)
+                        let resolved_name = &ToolchainName::try_from(toolchain_name_str)?;
+                        if !self.list_toolchains()?.iter().any(|s| s == resolved_name) {
+                            return Err(anyhow!(format!("target triple in channel name '{name}'")));
                         }
                     }
 

src/dist/component/components.rs

@@ -30,13 +30,13 @@ impl Components {
         let c = Self { prefix };
 
         // Validate that the metadata uses a format we know
-        if let Some(v) = c.read_version()? {
-            if v != INSTALLER_VERSION {
-                bail!(
-                    "unsupported metadata version in existing installation: {}",
-                    v
-                );
-            }
+        if let Some(v) = c.read_version()?
+            && v != INSTALLER_VERSION
+        {
+            bail!(
+                "unsupported metadata version in existing installation: {}",
+                v
+            );
         }
 
         Ok(c)

src/dist/component/package.rs

@@ -254,26 +254,26 @@ fn trigger_children(
     op: CompletedIo,
 ) -> Result<usize> {
     let mut result = 0;
-    if let CompletedIo::Item(item) = op {
-        if let Kind::Directory = item.kind {
-            let mut pending = Vec::new();
-            directories
-                .entry(item.full_path)
-                .and_modify(|status| match status {
-                    DirStatus::Exists => unreachable!(),
-                    DirStatus::Pending(pending_inner) => {
-                        pending.append(pending_inner);
-                        *status = DirStatus::Exists;
-                    }
-                })
-                .or_insert_with(|| unreachable!());
-            result += pending.len();
-            for pending_item in pending.into_iter() {
-                for mut item in io_executor.execute(pending_item).collect::<Vec<_>>() {
-                    // TODO capture metrics
-                    filter_result(&mut item)?;
-                    result += trigger_children(io_executor, directories, item)?;
+    if let CompletedIo::Item(item) = op
+        && let Kind::Directory = item.kind
+    {
+        let mut pending = Vec::new();
+        directories
+            .entry(item.full_path)
+            .and_modify(|status| match status {
+                DirStatus::Exists => unreachable!(),
+                DirStatus::Pending(pending_inner) => {
+                    pending.append(pending_inner);
+                    *status = DirStatus::Exists;
                 }
+            })
+            .or_insert_with(|| unreachable!());
+        result += pending.len();
+        for pending_item in pending.into_iter() {
+            for mut item in io_executor.execute(pending_item).collect::<Vec<_>>() {
+                // TODO capture metrics
+                filter_result(&mut item)?;
+                result += trigger_children(io_executor, directories, item)?;
             }
         }
     };
@@ -363,24 +363,24 @@ fn unpack_without_first_dir<R: Read>(
                 trigger_children(&*io_executor, directories, op)?;
             }
             // Maybe stream a file incrementally
-            if let Some(sender) = sender_entry.as_mut() {
-                if io_executor.buffer_available(IO_CHUNK_SIZE) {
-                    let mut buffer = io_executor.get_buffer(IO_CHUNK_SIZE);
-                    let len = sender
-                        .entry
-                        .by_ref()
-                        .take(IO_CHUNK_SIZE as u64)
-                        .read_to_end(&mut buffer)?;
-                    buffer = buffer.finished();
-                    if len == 0 {
-                        result = true;
-                    }
-                    if !(sender.sender)(buffer) {
-                        bail!(format!(
-                            "IO receiver for '{}' disconnected",
-                            full_path.as_ref().display()
-                        ))
-                    }
+            if let Some(sender) = sender_entry.as_mut()
+                && io_executor.buffer_available(IO_CHUNK_SIZE)
+            {
+                let mut buffer = io_executor.get_buffer(IO_CHUNK_SIZE);
+                let len = sender
+                    .entry
+                    .by_ref()
+                    .take(IO_CHUNK_SIZE as u64)
+                    .read_to_end(&mut buffer)?;
+                buffer = buffer.finished();
+                if len == 0 {
+                    result = true;
+                }
+                if !(sender.sender)(buffer) {
+                    bail!(format!(
+                        "IO receiver for '{}' disconnected",
+                        full_path.as_ref().display()
+                    ))
                 }
             }
             Ok(result)

src/dist/mod.rs

@@ -229,13 +229,13 @@ impl FromStr for PartialVersion {
         // `semver::Comparator::from_str` supports an optional operator
         // (e.g. `=`, `>`, `>=`, `<`, `<=`, `~`, `^`, `*`) before the
         // partial version, so we should exclude that case first.
-        if let Some(ch) = ver.chars().nth(0) {
-            if !ch.is_ascii_digit() {
-                return Err(anyhow!(
-                    "expected ASCII digit at the beginning of `{ver}`, found `{ch}`"
-                )
-                .context("error parsing `PartialVersion`"));
-            }
+        if let Some(ch) = ver.chars().nth(0)
+            && !ch.is_ascii_digit()
+        {
+            return Err(
+                anyhow!("expected ASCII digit at the beginning of `{ver}`, found `{ch}`")
+                    .context("error parsing `PartialVersion`"),
+            );
         }
         let (ver, pre) = ver.split_once('-').unwrap_or((ver, ""));
         let comparator =
@@ -1017,12 +1017,12 @@ pub(crate) async fn update_from_dist(
             }
         };
 
-        if let Some(backtrack_limit) = backtrack_limit {
-            if backtrack_limit < 1 {
-                // This unwrap is safe because we can only hit this if we've
-                // had a chance to set first_err
-                break Err(first_err.unwrap());
-            }
+        if let Some(backtrack_limit) = backtrack_limit
+            && backtrack_limit < 1
+        {
+            // This unwrap is safe because we can only hit this if we've
+            // had a chance to set first_err
+            break Err(first_err.unwrap());
         }
 
         // The user asked to update their nightly, but the latest nightly does not have all
@@ -1118,10 +1118,9 @@ async fn try_update_from_dist_(
                     .components
                     .iter()
                     .find(|c| c.short_name_in_manifest() == component.short_name_in_manifest())
+                    && c.target.is_none()
                 {
-                    if c.target.is_none() {
-                        component = component.wildcard();
-                    }
+                    component = component.wildcard();
                 }
                 all_components.insert(component);
             }
@@ -1215,12 +1214,12 @@ async fn try_update_from_dist_(
         .await;
 
     // inspect, determine what context to add, then process afterwards.
-    if let Err(e) = &result {
-        if let Some(RustupError::DownloadNotExists { .. }) = e.downcast_ref::<RustupError>() {
-            return result.with_context(|| {
-                format!("could not download nonexistent rust version `{toolchain_str}`")
-            });
-        }
+    if let Err(e) = &result
+        && let Some(RustupError::DownloadNotExists { .. }) = e.downcast_ref::<RustupError>()
+    {
+        return result.with_context(|| {
+            format!("could not download nonexistent rust version `{toolchain_str}`")
+        });
     }
 
     result

src/download/mod.rs

@@ -100,10 +100,10 @@ async fn download_file_(
     // This callback will write the download to disk and optionally
     // hash the contents, then forward the notification up the stack
     let callback: &dyn Fn(Event<'_>) -> anyhow::Result<()> = &|msg| {
-        if let Event::DownloadDataReceived(data) = msg {
-            if let Some(h) = hasher.borrow_mut().as_mut() {
-                h.update(data);
-            }
+        if let Event::DownloadDataReceived(data) = msg
+            && let Some(h) = hasher.borrow_mut().as_mut()
+        {
+            h.update(data);
         }
 
         match msg {
@@ -469,18 +469,17 @@ mod curl {
                 // Listen for headers and parse out a `Content-Length` (case-insensitive) if it
                 // comes so we know how much we're downloading.
                 transfer.header_function(|header| {
-                    if let Ok(data) = str::from_utf8(header) {
-                        let prefix = "content-length: ";
-                        if data.to_ascii_lowercase().starts_with(prefix) {
-                            if let Ok(s) = data[prefix.len()..].trim().parse::<u64>() {
-                                let msg = Event::DownloadContentLengthReceived(s + resume_from);
-                                match callback(msg) {
-                                    Ok(()) => (),
-                                    Err(e) => {
-                                        *cberr.borrow_mut() = Some(e);
-                                        return false;
-                                    }
-                                }
+                    let prefix = "content-length: ";
+                    if let Ok(data) = str::from_utf8(header)
+                        && data.to_ascii_lowercase().starts_with(prefix)
+                        && let Ok(s) = data[prefix.len()..].trim().parse::<u64>()
+                    {
+                        let msg = Event::DownloadContentLengthReceived(s + resume_from);
+                        match callback(msg) {
+                            Ok(()) => (),
+                            Err(e) => {
+                                *cberr.borrow_mut() = Some(e);
+                                return false;
                             }
                         }
                     }

src/env_var.rs

@@ -27,10 +27,10 @@ pub(crate) fn insert_path(
         prepend.into()
     };
 
-    if let Some(path) = append {
-        if !parts.contains(&path) {
-            parts.push_back(path);
-        }
+    if let Some(path) = append
+        && !parts.contains(&path)
+    {
+        parts.push_back(path);
     }
 
     if let Ok(new_value) = env::join_paths(parts) {

src/toolchain.rs

@@ -345,15 +345,15 @@ impl<'a> Toolchain<'a> {
                 );
                 return Ok(cmd);
             }
-        } else if let "rust-analyzer" | "rust-analyzer.exe" = binary {
-            if let Some(cmd) = self.maybe_do_rust_analyzer_fallback(binary)? {
-                info!("`rust-analyzer` is unavailable for the active toolchain");
-                info!(
-                    r#"falling back to "{}""#,
-                    Path::new(cmd.get_program()).display()
-                );
-                return Ok(cmd);
-            }
+        } else if let "rust-analyzer" | "rust-analyzer.exe" = binary
+            && let Some(cmd) = self.maybe_do_rust_analyzer_fallback(binary)?
+        {
+            info!("`rust-analyzer` is unavailable for the active toolchain");
+            info!(
+                r#"falling back to "{}""#,
+                Path::new(cmd.get_program()).display()
+            );
+            return Ok(cmd);
         }
 
         self.create_command(binary)
@@ -490,12 +490,12 @@ impl<'a> Toolchain<'a> {
         // but only if we know the absolute path to cargo.
         // This works around an issue with old versions of cargo not updating
         // the environment variable itself.
-        if Path::new(&binary).file_stem() == Some("cargo".as_ref()) && path.is_absolute() {
-            if let Some(cargo) = self.cfg.process.var_os("CARGO") {
-                if fs::read_link(&cargo).is_ok_and(|p| p.file_stem() == Some("rustup".as_ref())) {
-                    cmd.env("CARGO", path);
-                }
-            }
+        if Path::new(&binary).file_stem() == Some("cargo".as_ref())
+            && path.is_absolute()
+            && let Some(cargo) = self.cfg.process.var_os("CARGO")
+            && fs::read_link(&cargo).is_ok_and(|p| p.file_stem() == Some("rustup".as_ref()))
+        {
+            cmd.env("CARGO", path);
         }
         Ok(cmd)
     }