Merge pull request #1890 from lzutao/fix-clippy

Fix clippy warnings

Author: kinnison

src/cli/download_tracker.rs

@@ -212,6 +212,7 @@ impl DownloadTracker {
 struct Duration(f64);
 
 impl fmt::Display for Duration {
+    #[allow(clippy::many_single_char_names)]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // repurposing the alternate mode for ETA
         let sec = self.0;
@@ -258,13 +259,13 @@ mod tests {
 
         assert_eq!(DownloadTracker::from_seconds(60), (0, 0, 1, 0));
 
-        assert_eq!(DownloadTracker::from_seconds(3600), (0, 1, 0, 0));
+        assert_eq!(DownloadTracker::from_seconds(3_600), (0, 1, 0, 0));
 
-        assert_eq!(DownloadTracker::from_seconds(3600 * 24), (1, 0, 0, 0));
+        assert_eq!(DownloadTracker::from_seconds(3_600 * 24), (1, 0, 0, 0));
 
-        assert_eq!(DownloadTracker::from_seconds(52292), (0, 14, 31, 32));
+        assert_eq!(DownloadTracker::from_seconds(52_292), (0, 14, 31, 32));
 
-        assert_eq!(DownloadTracker::from_seconds(222292), (2, 13, 44, 52));
+        assert_eq!(DownloadTracker::from_seconds(222_292), (2, 13, 44, 52));
     }
 
 }

src/cli/errors.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::large_enum_variant)]
 #![allow(dead_code)]
 
 use crate::rustup_mode::CompletionCommand;

src/cli/main.rs

@@ -48,7 +48,7 @@ fn run_rustup() -> Result<()> {
         open_trace_file!(dir)?;
     }
     let result = run_rustup_inner();
-    if let Ok(_) = env::var("RUSTUP_TRACE_DIR") {
+    if env::var("RUSTUP_TRACE_DIR").is_ok() {
         close_trace_file!();
     }
     result

src/cli/rustup_mode.rs

@@ -1146,7 +1146,7 @@ pub enum CompletionCommand {
     Cargo,
 }
 
-static COMPLETIONS: &[(&'static str, CompletionCommand)] = &[
+static COMPLETIONS: &[(&str, CompletionCommand)] = &[
     ("rustup", CompletionCommand::Rustup),
     ("cargo", CompletionCommand::Cargo),
 ];

src/config.rs

@@ -95,7 +95,7 @@ impl Cfg {
         );
         let dist_root = dist_root_server.clone() + "/dist";
 
-        let cfg = Cfg {
+        let cfg = Self {
             rustup_dir,
             settings_file,
             toolchains_dir,

src/diskio/immediate.rs

@@ -4,15 +4,16 @@
 /// threaded code paths.
 use super::{perform, Executor, Item};
 
+#[derive(Default)]
 pub struct ImmediateUnpacker {}
 impl ImmediateUnpacker {
-    pub fn new<'a>() -> ImmediateUnpacker {
-        ImmediateUnpacker {}
+    pub fn new() -> Self {
+        Self {}
     }
 }
 
 impl Executor for ImmediateUnpacker {
-    fn dispatch(&mut self, mut item: Item) -> Box<dyn '_ + Iterator<Item = Item>> {
+    fn dispatch(&mut self, mut item: Item) -> Box<dyn Iterator<Item = Item> + '_> {
         perform(&mut item);
         Box::new(Some(item).into_iter())
     }

src/diskio/mod.rs

@@ -89,7 +89,7 @@ pub struct Item {
 
 impl Item {
     pub fn make_dir(full_path: PathBuf, mode: u32) -> Self {
-        Item {
+        Self {
             full_path,
             kind: Kind::Directory,
             start: 0.0,
@@ -102,7 +102,7 @@ impl Item {
 
     pub fn write_file(full_path: PathBuf, content: Vec<u8>, mode: u32) -> Self {
         let len = content.len();
-        Item {
+        Self {
             full_path,
             kind: Kind::File(content),
             start: 0.0,
@@ -122,24 +122,24 @@ pub trait Executor {
     /// During overload situations previously queued items may
     /// need to be completed before the item is accepted:
     /// consume the returned iterator.
-    fn execute(&mut self, mut item: Item) -> Box<dyn '_ + Iterator<Item = Item>> {
+    fn execute(&mut self, mut item: Item) -> Box<dyn Iterator<Item = Item> + '_> {
         item.start = precise_time_s();
         self.dispatch(item)
     }
 
     /// Actually dispatch a operation.
     /// This is called by the default execute() implementation and
     /// should not be called directly.
-    fn dispatch(&mut self, item: Item) -> Box<dyn '_ + Iterator<Item = Item>>;
+    fn dispatch(&mut self, item: Item) -> Box<dyn Iterator<Item = Item> + '_>;
 
     /// Wrap up any pending operations and iterate over them.
     /// All operations submitted before the join will have been
     /// returned either through ready/complete or join once join
     /// returns.
-    fn join(&mut self) -> Box<dyn '_ + Iterator<Item = Item>>;
+    fn join(&mut self) -> Box<dyn Iterator<Item = Item> + '_>;
 
     /// Iterate over completed items.
-    fn completed(&mut self) -> Box<dyn '_ + Iterator<Item = Item>>;
+    fn completed(&mut self) -> Box<dyn Iterator<Item = Item> + '_>;
 }
 
 /// Trivial single threaded IO to be used from executors.
@@ -200,15 +200,13 @@ pub fn get_executor<'a>(
     if let Ok(thread_str) = env::var("RUSTUP_IO_THREADS") {
         if thread_str == "disabled" {
             Box::new(immediate::ImmediateUnpacker::new())
+        } else if let Ok(thread_count) = thread_str.parse::<usize>() {
+            Box::new(threaded::Threaded::new_with_threads(
+                notify_handler,
+                thread_count,
+            ))
         } else {
-            if let Ok(thread_count) = thread_str.parse::<usize>() {
-                Box::new(threaded::Threaded::new_with_threads(
-                    notify_handler,
-                    thread_count,
-                ))
-            } else {
-                Box::new(threaded::Threaded::new(notify_handler))
-            }
+            Box::new(threaded::Threaded::new(notify_handler))
         }
     } else {
         Box::new(threaded::Threaded::new(notify_handler))

src/diskio/threaded.rs

@@ -89,7 +89,7 @@ impl<'a> Threaded<'a> {
 }
 
 impl<'a> Executor for Threaded<'a> {
-    fn dispatch(&mut self, item: Item) -> Box<dyn '_ + Iterator<Item = Item>> {
+    fn dispatch(&mut self, item: Item) -> Box<dyn Iterator<Item = Item> + '_> {
         // Yield any completed work before accepting new work - keep memory
         // pressure under control
         // - return an iterator that runs until we can submit and then submits
@@ -100,7 +100,7 @@ impl<'a> Executor for Threaded<'a> {
         })
     }
 
-    fn join(&mut self) -> Box<dyn '_ + Iterator<Item = Item>> {
+    fn join(&mut self) -> Box<dyn Iterator<Item = Item> + '_> {
         // Some explanation is in order. Even though the tar we are reading from (if
         // any) will have had its FileWithProgress download tracking
         // completed before we hit drop, that is not true if we are unwinding due to a
@@ -115,16 +115,14 @@ impl<'a> Executor for Threaded<'a> {
         // items, and the download tracker's progress is confounded with
         // actual handling of data today, we synthesis a data buffer and
         // pretend to have bytes to deliver.
-        self.notify_handler
-            .map(|handler| handler(Notification::DownloadFinished));
-        self.notify_handler
-            .map(|handler| handler(Notification::DownloadPushUnits("iops")));
         let mut prev_files = self.n_files.load(Ordering::Relaxed);
-        self.notify_handler.map(|handler| {
+        if let Some(handler) = self.notify_handler {
+            handler(Notification::DownloadFinished);
+            handler(Notification::DownloadPushUnits("iops"));
             handler(Notification::DownloadContentLengthReceived(
                 prev_files as u64,
-            ))
-        });
+            ));
+        }
         if prev_files > 50 {
             println!("{} deferred IO operations", prev_files);
         }
@@ -139,14 +137,15 @@ impl<'a> Executor for Threaded<'a> {
             prev_files = current_files;
             current_files = self.n_files.load(Ordering::Relaxed);
             let step_count = prev_files - current_files;
-            self.notify_handler
-                .map(|handler| handler(Notification::DownloadDataReceived(&buf[0..step_count])));
+            if let Some(handler) = self.notify_handler {
+                handler(Notification::DownloadDataReceived(&buf[0..step_count]));
+            }
         }
         self.pool.join();
-        self.notify_handler
-            .map(|handler| handler(Notification::DownloadFinished));
-        self.notify_handler
-            .map(|handler| handler(Notification::DownloadPopUnits));
+        if let Some(handler) = self.notify_handler {
+            handler(Notification::DownloadFinished);
+            handler(Notification::DownloadPopUnits);
+        }
         // close the feedback channel so that blocking reads on it can
         // complete. send is atomic, and we know the threads completed from the
         // pool join, so this is race-free. It is possible that try_iter is safe
@@ -167,7 +166,7 @@ impl<'a> Executor for Threaded<'a> {
         })
     }
 
-    fn completed(&mut self) -> Box<dyn '_ + Iterator<Item = Item>> {
+    fn completed(&mut self) -> Box<dyn Iterator<Item = Item> + '_> {
         Box::new(JoinIterator {
             iter: self.rx.try_iter(),
             consume_sentinel: true,

src/dist/component/components.rs

@@ -20,7 +20,7 @@ pub struct Components {
 
 impl Components {
     pub fn open(prefix: InstallPrefix) -> Result<Self> {
-        let c = Components { prefix };
+        let c = Self { prefix };
 
         // Validate that the metadata uses a format we know
         if let Some(v) = c.read_version()? {
@@ -152,7 +152,7 @@ impl ComponentPart {
     }
     pub fn decode(line: &str) -> Option<Self> {
         line.find(':')
-            .map(|pos| ComponentPart(line[0..pos].to_owned(), PathBuf::from(&line[(pos + 1)..])))
+            .map(|pos| Self(line[0..pos].to_owned(), PathBuf::from(&line[(pos + 1)..])))
     }
 }
 

src/dist/component/package.rs

@@ -52,7 +52,7 @@ impl DirectoryPackage {
             .lines()
             .map(std::borrow::ToOwned::to_owned)
             .collect();
-        Ok(DirectoryPackage {
+        Ok(Self {
             path,
             components,
             copy,
@@ -165,7 +165,7 @@ struct MemoryBudget {
 
 // Probably this should live in diskio but ¯\_(ツ)_/¯
 impl MemoryBudget {
-    fn new(max_file_size: usize) -> MemoryBudget {
+    fn new(max_file_size: usize) -> Self {
         const DEFAULT_UNPACK_RAM: usize = 400 * 1024 * 1024;
         let unpack_ram = if let Ok(budget_str) = env::var("RUSTUP_UNPACK_RAM") {
             if let Ok(budget) = budget_str.parse::<usize>() {
@@ -179,7 +179,7 @@ impl MemoryBudget {
         if max_file_size > unpack_ram {
             panic!("RUSTUP_UNPACK_RAM must be larger than {}", max_file_size);
         }
-        MemoryBudget {
+        Self {
             limit: unpack_ram,
             used: 0,
         }