Fix all current clippy lints

rbtcollins · rbtcollins · commit e6c0a3c3a73e · 2020-08-14T22:03:06.000+12:00
diff --git a/src/cli/common.rs b/src/cli/common.rs
@@ -183,7 +183,7 @@ fn show_channel_updates(
 ) -> Result<()> {
     let data = toolchains.into_iter().map(|(name, result)| {
         let toolchain = cfg.get_toolchain(&name, false).unwrap();
-        let mut version: String = toolchain.rustc_version().into();
+        let mut version: String = toolchain.rustc_version();
 
         let banner;
         let color;
@@ -486,12 +486,12 @@ pub fn list_toolchains(cfg: &Cfg, verbose: bool) -> Result<utils::ExitCode> {
             String::new()
         };
         for toolchain in toolchains {
-            let if_default = if def_toolchain_name == &*toolchain {
+            let if_default = if def_toolchain_name == *toolchain {
                 " (default)"
             } else {
                 ""
             };
-            let if_override = if ovr_toolchain_name == &*toolchain {
+            let if_override = if ovr_toolchain_name == *toolchain {
                 " (override)"
             } else {
                 ""
diff --git a/src/cli/self_update.rs b/src/cli/self_update.rs
@@ -1149,7 +1149,7 @@ info: default host triple is {0}
             vars,
             ..Default::default()
         });
-        currentprocess::with(tp.clone(), || -> anyhow::Result<()> {
+        currentprocess::with(tp, || -> anyhow::Result<()> {
             super::install_bins().unwrap();
             Ok(())
         })
diff --git a/src/cli/self_update/windows.rs b/src/cli/self_update/windows.rs
@@ -214,7 +214,7 @@ fn get_windows_path_var() -> Result<Option<String>> {
             } else {
                 warn!("the registry key HKEY_CURRENT_USER\\Environment\\PATH does not contain valid Unicode. \
                        Not modifying the PATH variable");
-                return Ok(None);
+                Ok(None)
             }
         }
         Err(ref e) if e.kind() == io::ErrorKind::NotFound => Ok(Some(String::new())),
@@ -230,7 +230,7 @@ fn _add_to_path(old_path: &str, path_str: String) -> Option<String> {
     } else if old_path.contains(&path_str) {
         None
     } else {
-        let mut new_path = path_str.clone();
+        let mut new_path = path_str;
         new_path.push_str(";");
         new_path.push_str(&old_path);
         Some(new_path)
@@ -471,8 +471,11 @@ mod tests {
                     .unwrap();
                 environment.delete_value("PATH").unwrap();
 
-                assert_eq!((), super::_apply_new_path(Some("foo".into())).unwrap());
-
+                {
+                    // Can't compare the Results as Eq isn't derived; thanks error-chain.
+                    #![allow(clippy::unit_cmp)]
+                    assert_eq!((), super::_apply_new_path(Some("foo".into())).unwrap());
+                }
                 let root = RegKey::predef(HKEY_CURRENT_USER);
                 let environment = root
                     .open_subkey_with_flags("Environment", KEY_READ | KEY_WRITE)
@@ -506,8 +509,11 @@ mod tests {
                     )
                     .unwrap();
 
-                assert_eq!((), super::_apply_new_path(Some("".into())).unwrap());
-
+                {
+                    // Can't compare the Results as Eq isn't derived; thanks error-chain.
+                    #![allow(clippy::unit_cmp)]
+                    assert_eq!((), super::_apply_new_path(Some("".into())).unwrap());
+                }
                 let reg_value = environment.get_raw_value("PATH");
                 match reg_value {
                     Ok(_) => panic!("key not deleted"),
diff --git a/src/cli/setup_mode.rs b/src/cli/setup_mode.rs
@@ -101,7 +101,7 @@ pub fn main() -> Result<utils::ExitCode> {
             writeln!(process().stdout().lock(), "{}", e.message)?;
             return Ok(utils::ExitCode(0));
         }
-        Err(e) => Err(e)?,
+        Err(e) => return Err(e.into()),
     };
     let no_prompt = matches.is_present("no-prompt");
     let verbose = matches.is_present("verbose");
diff --git a/src/cli/term2.rs b/src/cli/term2.rs
@@ -76,26 +76,26 @@ mod termhack {
     /// opened.
     #[allow(unused)]
     pub fn stdout(terminfo: Option<TermInfo>) -> Option<Box<StdoutTerminal>> {
-        make_terminal(terminfo, || io::stdout())
+        make_terminal(terminfo, io::stdout)
     }
 
     /// Return a Terminal wrapping stderr, or None if a terminal couldn't be
     /// opened.
     #[allow(unused)]
     pub fn stderr(terminfo: Option<TermInfo>) -> Option<Box<StderrTerminal>> {
-        make_terminal(terminfo, || io::stderr())
+        make_terminal(terminfo, io::stderr)
     }
 
     /// Return a Terminal wrapping stdout.
     #[allow(unused)]
     pub fn stdout_with_fallback(terminfo: Option<TermInfo>) -> Box<StdoutTerminal> {
-        make_terminal_with_fallback(terminfo, || io::stdout())
+        make_terminal_with_fallback(terminfo, io::stdout)
     }
 
     /// Return a Terminal wrapping stderr.
     #[allow(unused)]
     pub fn stderr_with_fallback(terminfo: Option<TermInfo>) -> Box<StderrTerminal> {
-        make_terminal_with_fallback(terminfo, || io::stderr())
+        make_terminal_with_fallback(terminfo, io::stderr)
     }
 }
 
diff --git a/src/config.rs b/src/config.rs
@@ -585,7 +585,7 @@ impl Cfg {
         let contents = contents.as_ref();
 
         match contents.lines().count() {
-            0 => return Err(ErrorKind::EmptyOverrideFile.into()),
+            0 => Err(ErrorKind::EmptyOverrideFile.into()),
             1 => {
                 let channel = contents.trim();
 
diff --git a/src/currentprocess.rs b/src/currentprocess.rs
@@ -147,8 +147,8 @@ where
     });
 
     PROCESS.with(|p| {
-        if let Some(_) = *p.borrow() {
-            panic!("current process already set {}");
+        if let Some(old_p) = &*p.borrow() {
+            panic!("current process already set {:?}", old_p);
         }
         *p.borrow_mut() = Some(process);
         let result = f();
diff --git a/src/dist/manifest.rs b/src/dist/manifest.rs
@@ -440,7 +440,7 @@ impl TargetedPackage {
         if !extensions.is_empty() {
             result.insert("extensions".to_owned(), toml::Value::Array(extensions));
         }
-        if let Some(bins) = self.bins.clone() {
+        if let Some(bins) = self.bins {
             result.insert("hash".to_owned(), toml::Value::String(bins.hash));
             result.insert("url".to_owned(), toml::Value::String(bins.url));
             if let (Some(xz_hash), Some(xz_url)) = (bins.xz_hash, bins.xz_url) {
diff --git a/src/dist/notifications.rs b/src/dist/notifications.rs
@@ -182,7 +182,7 @@ impl<'a> Display for Notification<'a> {
                     .iter()
                     .map(|component| {
                         if component.target.as_ref() != Some(&toolchain.target) {
-                            component.name_in_manifest().to_owned()
+                            component.name_in_manifest()
                         } else {
                             component.short_name_in_manifest().to_owned()
                         }
diff --git a/src/test.rs b/src/test.rs
@@ -86,9 +86,7 @@ pub fn this_host_triple() -> String {
         // building with i686 toolchain, but on an x86_64 host, so run the
         // actual detection logic and trust it.
         let tp = Box::new(currentprocess::TestProcess::default());
-        return currentprocess::with(tp.clone(), || {
-            TargetTriple::from_host().unwrap().to_string()
-        });
+        return currentprocess::with(tp, || TargetTriple::from_host().unwrap().to_string());
     }
     let arch = if cfg!(target_arch = "x86") {
         "i686"
diff --git a/src/toolchain.rs b/src/toolchain.rs
@@ -287,10 +287,9 @@ impl<'a> InstalledCommonToolchain<'a> {
                         let component_status = component_statuses
                             .iter()
                             .find(|cs| cs.component.short_name(&manifest) == component_name)
-                            .expect(&format!(
-                                "component {} should be in the manifest",
-                                component_name
-                            ));
+                            .unwrap_or_else(|| {
+                                panic!("component {} should be in the manifest", component_name)
+                            });
                         if !component_status.available {
                             return Err(ErrorKind::BinaryProvidedByUnavailableComponent(
                                 component_status.component.short_name(&manifest),
@@ -692,7 +691,7 @@ impl<'a> DistributableToolchain<'a> {
             force_update,
             allow_downgrade,
             exists: self.0.exists(),
-            old_date: old_date.as_ref().map(|s| &**s),
+            old_date: old_date.as_deref(),
             components,
             targets,
             distributable: &self,
diff --git a/src/utils/utils.rs b/src/utils/utils.rs
@@ -548,11 +548,11 @@ pub fn string_from_winreg_value(val: &winreg::RegValue) -> Option<String> {
                 #[allow(clippy::cast_ptr_alignment)]
                 slice::from_raw_parts(val.bytes.as_ptr().cast::<u16>(), val.bytes.len() / 2)
             };
-            String::from_utf16(words).ok().and_then(|mut s| {
+            String::from_utf16(words).ok().map(|mut s| {
                 while s.ends_with('\u{0}') {
                     s.pop();
                 }
-                Some(s)
+                s
             })
         }
         _ => None,
@@ -593,6 +593,7 @@ pub fn toolchain_sort<T: AsRef<str>>(v: &mut Vec<T>) {
     });
 }
 
+#[cfg(target_os = "linux")]
 fn copy_and_delete<'a, N>(
     name: &'static str,
     src: &'a Path,
diff --git a/tests/cli-rustup.rs b/tests/cli-rustup.rs
@@ -1920,7 +1920,7 @@ fn non_utf8_toolchain() {
         let out = run(
             config,
             "rustc",
-            &[OsString::from_wide(&[u16::from('+' as u8), 0xd801, 0xd801])],
+            &[OsString::from_wide(&[u16::from(b'+'), 0xd801, 0xd801])],
             &[("RUST_BACKTRACE", "1")],
         );
         assert!(out.stderr.contains("toolchain '��' is not installed"));
diff --git a/tests/cli-self-upd.rs b/tests/cli-self-upd.rs
@@ -333,11 +333,10 @@ fn uninstall_doesnt_leave_gc_file() {
 #[test]
 fn update_exact() {
     let version = env!("CARGO_PKG_VERSION");
-    let expected_output = format!(
-        "info: checking for self-updates
+    let expected_output = "info: checking for self-updates
 info: downloading self-update
 "
-    );
+    .to_string();
 
     update_setup(&|config, _| {
         expect_ok(config, &["rustup-init", "-y", "--no-modify-path"]);
diff --git a/tests/cli-v2.rs b/tests/cli-v2.rs
@@ -985,7 +985,7 @@ fn remove_target_host() {
     setup(&|config| {
         let trip = this_host_triple();
         expect_ok(config, &["rustup", "default", "nightly"]);
-        expect_ok(config, &["rustup", "target", "remove", &trip.to_string()]);
+        expect_ok(config, &["rustup", "target", "remove", &trip]);
     });
 }
 
diff --git a/tests/mock/clitools.rs b/tests/mock/clitools.rs
@@ -516,11 +516,7 @@ where
         run_subprocess(config, name, args, env)
     };
     let output = SanitizedOutput {
-        ok: if let Some(0) = out.status {
-            true
-        } else {
-            false
-        },
+        ok: matches!(out.status, Some(0)),
         stdout: String::from_utf8(out.stdout).unwrap(),
         stderr: String::from_utf8(out.stderr).unwrap(),
     };
@@ -560,7 +556,7 @@ where
         vars,
         "",
     ));
-    let process_res = currentprocess::with(tp.clone(), || rustup_mode::main());
+    let process_res = currentprocess::with(tp.clone(), rustup_mode::main);
     // convert Err's into an ec
     let ec = match process_res {
         Ok(process_res) => process_res,
@@ -694,22 +690,20 @@ impl Release {
                 self.multi_arch,
                 false,
             )
+        } else if self.multi_arch {
+            // unavailable but multiarch means to build only with host==MULTI_ARCH1
+            // instead of true multiarch
+            build_mock_channel(
+                &self.channel,
+                &self.date,
+                &self.version,
+                &self.hash,
+                self.rls,
+                false,
+                true,
+            )
         } else {
-            if self.multi_arch {
-                // unavailable but multiarch means to build only with host==MULTI_ARCH1
-                // instead of true multiarch
-                build_mock_channel(
-                    &self.channel,
-                    &self.date,
-                    &self.version,
-                    &self.hash,
-                    self.rls,
-                    false,
-                    true,
-                )
-            } else {
-                build_mock_unavailable_channel(&self.channel, &self.date, &self.version, &self.hash)
-            }
+            build_mock_unavailable_channel(&self.channel, &self.date, &self.version, &self.hash)
         }
     }
 
@@ -1176,7 +1170,7 @@ fn build_mock_rust_doc_installer() -> MockInstallerBuilder {
     MockInstallerBuilder {
         components: vec![MockComponentBuilder {
             name: "rust-docs".to_string(),
-            files: files,
+            files,
         }],
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ pub fn main() -> Result<utils::ExitCode> {`
`101`	`101`	`writeln!(process().stdout().lock(), "{}", e.message)?;`
`102`	`102`	`return Ok(utils::ExitCode(0));`
`103`	`103`	`}`
`104`		`- Err(e) => Err(e)?,`
	`104`	`+ Err(e) => return Err(e.into()),`
`105`	`105`	`};`
`106`	`106`	`let no_prompt = matches.is_present("no-prompt");`
`107`	`107`	`let verbose = matches.is_present("verbose");`
Original file line number	Diff line number	Diff line change
`@@ -76,26 +76,26 @@ mod termhack {`
`76`	`76`	`/// opened.`
`77`	`77`	`#[allow(unused)]`
`78`	`78`	`pub fn stdout(terminfo: Option<TermInfo>) -> Option<Box<StdoutTerminal>> {`
`79`		`- make_terminal(terminfo, \|\| io::stdout())`
	`79`	`+ make_terminal(terminfo, io::stdout)`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`/// Return a Terminal wrapping stderr, or None if a terminal couldn't be`
`83`	`83`	`/// opened.`
`84`	`84`	`#[allow(unused)]`
`85`	`85`	`pub fn stderr(terminfo: Option<TermInfo>) -> Option<Box<StderrTerminal>> {`
`86`		`- make_terminal(terminfo, \|\| io::stderr())`
	`86`	`+ make_terminal(terminfo, io::stderr)`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`/// Return a Terminal wrapping stdout.`
`90`	`90`	`#[allow(unused)]`
`91`	`91`	`pub fn stdout_with_fallback(terminfo: Option<TermInfo>) -> Box<StdoutTerminal> {`
`92`		`- make_terminal_with_fallback(terminfo, \|\| io::stdout())`
	`92`	`+ make_terminal_with_fallback(terminfo, io::stdout)`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`/// Return a Terminal wrapping stderr.`
`96`	`96`	`#[allow(unused)]`
`97`	`97`	`pub fn stderr_with_fallback(terminfo: Option<TermInfo>) -> Box<StderrTerminal> {`
`98`		`- make_terminal_with_fallback(terminfo, \|\| io::stderr())`
	`98`	`+ make_terminal_with_fallback(terminfo, io::stderr)`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
Original file line number	Diff line number	Diff line change
`@@ -440,7 +440,7 @@ impl TargetedPackage {`
`440`	`440`	`if !extensions.is_empty() {`
`441`	`441`	`result.insert("extensions".to_owned(), toml::Value::Array(extensions));`
`442`	`442`	`}`
`443`		`- if let Some(bins) = self.bins.clone() {`
	`443`	`+ if let Some(bins) = self.bins {`
`444`	`444`	`result.insert("hash".to_owned(), toml::Value::String(bins.hash));`
`445`	`445`	`result.insert("url".to_owned(), toml::Value::String(bins.url));`
`446`	`446`	`if let (Some(xz_hash), Some(xz_url)) = (bins.xz_hash, bins.xz_url) {`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ impl<'a> Display for Notification<'a> {`
`182`	`182`	`.iter()`
`183`	`183`	`.map(\|component\| {`
`184`	`184`	`if component.target.as_ref() != Some(&toolchain.target) {`
`185`		`- component.name_in_manifest().to_owned()`
	`185`	`+ component.name_in_manifest()`
`186`	`186`	`} else {`
`187`	`187`	`component.short_name_in_manifest().to_owned()`
`188`	`188`	`}`