refactor: clean up clippy::perf lint warnings (#15631)

### What does this PR try to resolve?

The `clippy::perf` lint group is fairly useful for catching bad
practices that might hurt performance marginally.

This PR fixes most of them except `clippy::large_enum_variant`, which
doesn't feel right at this moment and need more researches. And that is
why I didn't enable the lint group.

### How to test and review this PR?

Author: epage

crates/cargo-test-support/src/paths.rs

@@ -66,7 +66,7 @@ pub fn global_root() -> PathBuf {
 // [*] It does set the thread name, but only when running concurrently. If not
 // running concurrently, all tests are run on the main thread.
 thread_local! {
-    static TEST_ID: RefCell<Option<usize>> = RefCell::new(None);
+    static TEST_ID: RefCell<Option<usize>> = const { RefCell::new(None) };
 }
 
 /// See [`init_root`]

crates/cargo-test-support/src/publish.rs

@@ -322,7 +322,7 @@ fn split_index_features(mut features: FeatureMap) -> (FeatureMap, Option<Feature
             .iter()
             .any(|value| value.starts_with("dep:") || value.contains("?/"))
         {
-            let new_values = values.drain(..).collect();
+            let new_values = std::mem::take(values);
             features2.insert(feat.clone(), new_values);
         }
     }

crates/cargo-test-support/src/registry.rs

@@ -646,15 +646,15 @@ pub struct HttpServerHandle {
 
 impl HttpServerHandle {
     pub fn index_url(&self) -> Url {
-        Url::parse(&format!("sparse+http://{}/index/", self.addr.to_string())).unwrap()
+        Url::parse(&format!("sparse+http://{}/index/", self.addr)).unwrap()
     }
 
     pub fn api_url(&self) -> Url {
-        Url::parse(&format!("http://{}/", self.addr.to_string())).unwrap()
+        Url::parse(&format!("http://{}/", self.addr)).unwrap()
     }
 
     pub fn dl_url(&self) -> Url {
-        Url::parse(&format!("http://{}/dl", self.addr.to_string())).unwrap()
+        Url::parse(&format!("http://{}/dl", self.addr)).unwrap()
     }
 
     fn stop(&self) {
@@ -892,7 +892,7 @@ impl HttpServer {
 
         // - The URL matches the registry base URL
         if footer.url != "https://github.com/rust-lang/crates.io-index"
-            && footer.url != &format!("sparse+http://{}/index/", self.addr.to_string())
+            && footer.url != &format!("sparse+http://{}/index/", self.addr)
         {
             return false;
         }

crates/mdman/src/format/man.rs

@@ -427,6 +427,7 @@ impl<'e> ManRenderer<'e> {
     }
 }
 
+#[allow(clippy::collapsible_str_replace)]
 fn escape(s: &str) -> Result<String, Error> {
     // Note: Possible source on output escape sequences: https://man7.org/linux/man-pages/man7/groff_char.7.html.
     //       Otherwise, use generic escaping in the form `\[u1EE7]` or `\[u1F994]`.

crates/resolver-tests/tests/proptests.rs

@@ -205,19 +205,15 @@ proptest! {
                     // If resolution was successful, then unpublishing a version of a crate
                     // that was not selected should not change that.
                     let not_selected: Vec<_> = input
-                        .iter()
-                        .cloned()
-                        .filter(|x| !r.contains(&x.package_id()))
+                        .iter().filter(|&x| !r.contains(&x.package_id())).cloned()
                         .collect();
 
                     if !not_selected.is_empty() {
                         let indexes_to_unpublish: Vec<_> = indexes_to_unpublish.iter().map(|x| x.get(&not_selected)).collect();
 
                         let new_reg = registry(
                             input
-                                .iter()
-                                .cloned()
-                                .filter(|x| !indexes_to_unpublish.contains(&x))
+                                .iter().filter(|&x| !indexes_to_unpublish.contains(&x)).cloned()
                                 .collect(),
                         );
 
@@ -248,9 +244,7 @@ proptest! {
 
                     let new_reg = registry(
                         input
-                            .iter()
-                            .cloned()
-                            .filter(|x| !indexes_to_unpublish.contains(&x))
+                            .iter().filter(|&x| !indexes_to_unpublish.contains(&x)).cloned()
                             .collect(),
                     );
 

crates/resolver-tests/tests/resolve.rs

@@ -741,8 +741,8 @@ fn incomplete_information_skipping() {
     let new_reg = registry(
         input
             .iter()
+            .filter(|&x| package_to_yank != x.package_id())
             .cloned()
-            .filter(|x| package_to_yank != x.package_id())
             .collect(),
     );
     assert_eq!(input.len(), new_reg.len() + 1);
@@ -810,8 +810,8 @@ fn incomplete_information_skipping_2() {
     let new_reg = registry(
         input
             .iter()
+            .filter(|&x| package_to_yank != x.package_id())
             .cloned()
-            .filter(|x| package_to_yank != x.package_id())
             .collect(),
     );
     assert_eq!(input.len(), new_reg.len() + 1);
@@ -860,8 +860,8 @@ fn incomplete_information_skipping_3() {
     let new_reg = registry(
         input
             .iter()
+            .filter(|&x| package_to_yank != x.package_id())
             .cloned()
-            .filter(|x| package_to_yank != x.package_id())
             .collect(),
     );
     assert_eq!(input.len(), new_reg.len() + 1);

src/cargo/core/features.rs

@@ -975,7 +975,7 @@ impl GitFeatures {
     }
 
     fn expecting() -> String {
-        let fields = vec!["`shallow-index`", "`shallow-deps`"];
+        let fields = ["`shallow-index`", "`shallow-deps`"];
         format!(
             "unstable 'git' only takes {} as valid inputs",
             fields.join(" and ")
@@ -1087,7 +1087,7 @@ impl GitoxideFeatures {
     }
 
     fn expecting() -> String {
-        let fields = vec!["`fetch`", "`checkout`", "`internal-use-git2`"];
+        let fields = ["`fetch`", "`checkout`", "`internal-use-git2`"];
         format!(
             "unstable 'gitoxide' only takes {} as valid inputs, for shallow fetches see `-Zgit=shallow-index,shallow-deps`",
             fields.join(" and ")

src/cargo/core/manifest.rs

@@ -151,7 +151,7 @@ impl ManifestMetadata {
     /// Whether the given env var should be tracked by Cargo's dep-info.
     pub fn should_track(env_key: &str) -> bool {
         let keys = MetadataEnvs::keys();
-        keys.iter().any(|k| *k == env_key)
+        keys.contains(&env_key)
     }
 
     pub fn env_var<'a>(&'a self, env_key: &str) -> Option<Cow<'a, str>> {
@@ -1016,21 +1016,21 @@ impl Target {
 
     pub fn is_dylib(&self) -> bool {
         match self.kind() {
-            TargetKind::Lib(libs) => libs.iter().any(|l| *l == CrateType::Dylib),
+            TargetKind::Lib(libs) => libs.contains(&CrateType::Dylib),
             _ => false,
         }
     }
 
     pub fn is_cdylib(&self) -> bool {
         match self.kind() {
-            TargetKind::Lib(libs) => libs.iter().any(|l| *l == CrateType::Cdylib),
+            TargetKind::Lib(libs) => libs.contains(&CrateType::Cdylib),
             _ => false,
         }
     }
 
     pub fn is_staticlib(&self) -> bool {
         match self.kind() {
-            TargetKind::Lib(libs) => libs.iter().any(|l| *l == CrateType::Staticlib),
+            TargetKind::Lib(libs) => libs.contains(&CrateType::Staticlib),
             _ => false,
         }
     }

src/cargo/core/package.rs

@@ -1182,7 +1182,7 @@ mod tls {
 
     use super::Downloads;
 
-    thread_local!(static PTR: Cell<usize> = Cell::new(0));
+    thread_local!(static PTR: Cell<usize> = const { Cell::new(0) });
 
     pub(crate) fn with<R>(f: impl FnOnce(Option<&Downloads<'_, '_>>) -> R) -> R {
         let ptr = PTR.with(|p| p.get());

src/cargo/core/resolver/encode.rs

@@ -698,7 +698,7 @@ impl ser::Serialize for Resolve {
                     None => "<none>",
                 };
                 let id = encodable_package_id(id, &state, self.version());
-                metadata.insert(format!("checksum {}", id.to_string()), checksum.to_string());
+                metadata.insert(format!("checksum {}", id), checksum.to_string());
             }
         }