remove ref where needless_borrowed_reference

Author: Eh2406

src/cargo/core/compiler/custom_build.rs

@@ -443,7 +443,7 @@ fn build_work(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Job> {
                     ))
                 })?;
                 let data = &script_output.metadata;
-                for &(ref key, ref value) in data.iter() {
+                for (key, value) in data.iter() {
                     cmd.env(
                         &format!("DEP_{}_{}", super::envify(&name), super::envify(key)),
                         value,

src/cargo/core/compiler/mod.rs

@@ -1318,7 +1318,7 @@ fn add_custom_flags(
                     cmd.arg("--check-cfg").arg(check_cfg);
                 }
             }
-            for &(ref name, ref value) in output.env.iter() {
+            for (name, value) in output.env.iter() {
                 cmd.env(name, value);
             }
         }

src/cargo/core/resolver/dep_cache.rs

@@ -128,9 +128,9 @@ impl<'a> RegistryQueryer<'a> {
             let mut potential_matches = self
                 .replacements
                 .iter()
-                .filter(|&&(ref spec, _)| spec.matches(summary.package_id()));
+                .filter(|(spec, _)| spec.matches(summary.package_id()));
 
-            let &(ref spec, ref dep) = match potential_matches.next() {
+            let (spec, dep) = match potential_matches.next() {
                 None => continue,
                 Some(replacement) => replacement,
             };
@@ -188,7 +188,7 @@ impl<'a> RegistryQueryer<'a> {
             let matched_spec = spec.clone();
 
             // Make sure no duplicates
-            if let Some(&(ref spec, _)) = potential_matches.next() {
+            if let Some((spec, _)) = potential_matches.next() {
                 return Poll::Ready(Err(anyhow::anyhow!(
                     "overlapping replacement specifications found:\n\n  \
                      * {}\n  * {}\n\nboth specifications match: {}",
@@ -278,7 +278,7 @@ impl<'a> RegistryQueryer<'a> {
         // dependencies with more candidates. This way if the dependency with
         // only one candidate can't be resolved we don't have to do a bunch of
         // work before we figure that out.
-        deps.sort_by_key(|&(_, ref a, _)| a.len());
+        deps.sort_by_key(|(_, a, _)| a.len());
 
         let out = Rc::new((used_features, Rc::new(deps)));
 

src/cargo/core/resolver/encode.rs

@@ -299,7 +299,7 @@ impl EncodableResolve {
 
         let mut g = Graph::new();
 
-        for &(ref id, _) in live_pkgs.values() {
+        for (id, _) in live_pkgs.values() {
             g.add(*id);
         }
 
@@ -435,7 +435,7 @@ fn build_path_deps(ws: &Workspace<'_>) -> CargoResult<HashMap<String, SourceId>>
             build_dep(dep, ws, &mut ret, &mut visited);
         }
     }
-    for &(_, ref dep) in ws.root_replace() {
+    for (_, dep) in ws.root_replace() {
         build_dep(dep, ws, &mut ret, &mut visited);
     }
 

src/cargo/core/resolver/mod.rs

@@ -234,7 +234,7 @@ fn activate_deps_loop(
     let mut past_conflicting_activations = conflict_cache::ConflictCache::new();
 
     // Activate all the initial summaries to kick off some work.
-    for &(ref summary, ref opts) in summaries {
+    for (summary, opts) in summaries {
         debug!("initial activation: {}", summary.package_id());
         let res = activate(
             &mut cx,
@@ -514,9 +514,7 @@ fn activate_deps_loop(
                             if let Some((other_parent, conflict)) = remaining_deps
                                 .iter()
                                 // for deps related to us
-                                .filter(|&(_, ref other_dep)| {
-                                    known_related_bad_deps.contains(other_dep)
-                                })
+                                .filter(|(_, other_dep)| known_related_bad_deps.contains(other_dep))
                                 .filter_map(|(other_parent, other_dep)| {
                                     past_conflicting_activations
                                         .find_conflicting(&cx, &other_dep, Some(pid))

src/cargo/core/workspace.rs

@@ -510,7 +510,7 @@ impl<'cfg> Workspace<'cfg> {
         self.members
             .iter()
             .filter_map(move |path| match packages.get(path) {
-                &MaybePackage::Package(ref p) => Some(p),
+                MaybePackage::Package(p) => Some(p),
                 _ => None,
             })
     }
@@ -541,7 +541,7 @@ impl<'cfg> Workspace<'cfg> {
         self.default_members
             .iter()
             .filter_map(move |path| match packages.get(path) {
-                &MaybePackage::Package(ref p) => Some(p),
+                MaybePackage::Package(p) => Some(p),
                 _ => None,
             })
     }
@@ -1046,7 +1046,7 @@ impl<'cfg> Workspace<'cfg> {
 
     pub fn load(&self, manifest_path: &Path) -> CargoResult<Package> {
         match self.packages.maybe_get(manifest_path) {
-            Some(&MaybePackage::Package(ref p)) => return Ok(p.clone()),
+            Some(MaybePackage::Package(p)) => return Ok(p.clone()),
             Some(&MaybePackage::Virtual(_)) => bail!("cannot load workspace root"),
             None => {}
         }

src/cargo/ops/cargo_compile/mod.rs

@@ -318,8 +318,8 @@ pub fn create_bcx<'a, 'cfg>(
     }
 
     let (extra_args, extra_args_name) = match (target_rustc_args, target_rustdoc_args) {
-        (&Some(ref args), _) => (Some(args.clone()), "rustc"),
-        (_, &Some(ref args)) => (Some(args.clone()), "rustdoc"),
+        (Some(args), _) => (Some(args.clone()), "rustc"),
+        (_, Some(args)) => (Some(args.clone()), "rustdoc"),
         _ => (None, ""),
     };
 

src/cargo/ops/resolve.rs

@@ -153,7 +153,7 @@ pub fn resolve_ws_with_opts<'cfg>(
 
         add_overrides(&mut registry, ws)?;
 
-        for &(ref replace_spec, ref dep) in ws.root_replace() {
+        for (replace_spec, dep) in ws.root_replace() {
             if !resolve
                 .iter()
                 .any(|r| replace_spec.matches(r) && !dep.matches_id(r))
@@ -486,7 +486,7 @@ pub fn resolve_with_previous<'cfg>(
     let replace = match previous {
         Some(r) => root_replace
             .iter()
-            .map(|&(ref spec, ref dep)| {
+            .map(|(spec, dep)| {
                 for (&key, &val) in r.replacements().iter() {
                     if spec.matches(key) && dep.matches_id(val) && keep(&val) {
                         let mut dep = dep.clone();

src/cargo/util/toml/targets.rs

@@ -744,7 +744,7 @@ https://github.com/rust-lang/cargo/issues/5330",
 fn inferred_to_toml_targets(inferred: &[(String, PathBuf)]) -> Vec<TomlTarget> {
     inferred
         .iter()
-        .map(|&(ref name, ref path)| TomlTarget {
+        .map(|(name, path)| TomlTarget {
             name: Some(name.clone()),
             path: Some(PathValue(path.clone())),
             ..TomlTarget::new()
@@ -926,8 +926,8 @@ fn target_path(
 
     let mut matching = inferred
         .iter()
-        .filter(|&&(ref n, _)| n == &name)
-        .map(|&(_, ref p)| p.clone());
+        .filter(|(n, _)| n == &name)
+        .map(|(_, p)| p.clone());
 
     let first = matching.next();
     let second = matching.next();