7 files changed, 22 insertions, 27 deletions

diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index e165b9c5f..1464320ba 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -197,7 +197,7 @@ fn eager_macro_recur(
     macro_resolver: &dyn Fn(ast::Path) -> Option<MacroDefId>,
     mut diagnostic_sink: &mut dyn FnMut(mbe::ExpandError),
 ) -> Result<SyntaxNode, ErrorEmitted> {
-    let original = curr.value.clone().clone_for_update();
+    let original = curr.value.clone_for_update();
 
     let children = original.descendants().filter_map(ast::MacroCall::cast);
     let mut replacements = Vec::new();
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 765a02b1c..03b97e7db 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -76,17 +76,17 @@ impl<'a> InferenceContext<'a> {
         // way around first would mean we make the type variable `!`, instead of
         // just marking it as possibly diverging.
         if self.coerce(&ty2, &ty1) {
-            ty1.clone()
+            ty1
         } else if self.coerce(&ty1, &ty2) {
-            ty2.clone()
+            ty2
         } else {
             if let Some(id) = id {
                 self.result
                     .type_mismatches
-                    .insert(id.into(), TypeMismatch { expected: ty1.clone(), actual: ty2.clone() });
+                    .insert(id.into(), TypeMismatch { expected: ty1.clone(), actual: ty2 });
             }
             cov_mark::hit!(coerce_merge_fail_fallback);
-            ty1.clone()
+            ty1
         }
     }
 
@@ -183,7 +183,7 @@ impl<'a> InferenceContext<'a> {
         // details of coercion errors though, so I think it's useful to leave
         // the structure like it is.
 
-        let canonicalized = self.canonicalize(from_ty.clone());
+        let canonicalized = self.canonicalize(from_ty);
         let autoderef = autoderef::autoderef(
             self.db,
             self.resolver.krate(),
@@ -389,7 +389,7 @@ impl<'a> InferenceContext<'a> {
                 // The CoerceUnsized trait should have two generic params: Self and T.
                 return Err(TypeError);
             }
-            b.push(coerce_from.clone()).push(to_ty.clone()).build()
+            b.push(coerce_from).push(to_ty.clone()).build()
         };
 
         let goal: InEnvironment<DomainGoal> =
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index eab8fac91..c0cbe19c1 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -44,7 +44,7 @@ impl<'a> InferenceContext<'a> {
             if !could_unify {
                 self.result.type_mismatches.insert(
                     tgt_expr.into(),
-                    TypeMismatch { expected: expected_ty.clone(), actual: ty.clone() },
+                    TypeMismatch { expected: expected_ty, actual: ty.clone() },
                 );
             }
         }
@@ -57,15 +57,14 @@ impl<'a> InferenceContext<'a> {
         let ty = self.infer_expr_inner(expr, &expected);
         let ty = if let Some(target) = expected.only_has_type(&mut self.table) {
             if !self.coerce(&ty, &target) {
-                self.result.type_mismatches.insert(
-                    expr.into(),
-                    TypeMismatch { expected: target.clone(), actual: ty.clone() },
-                );
+                self.result
+                    .type_mismatches
+                    .insert(expr.into(), TypeMismatch { expected: target, actual: ty.clone() });
                 // Return actual type when type mismatch.
                 // This is needed for diagnostic when return type mismatch.
                 ty
             } else {
-                target.clone()
+                target
             }
         } else {
             ty
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 9c8e3b6ae..83e0a7a9e 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -196,7 +196,7 @@ impl<'a> InferenceContext<'a> {
                 let inner_ty = if let Some(subpat) = subpat {
                     self.infer_pat(*subpat, &expected, default_bm)
                 } else {
-                    expected.clone()
+                    expected
                 };
                 let inner_ty = self.insert_type_vars_shallow(inner_ty);
 
@@ -266,10 +266,9 @@ impl<'a> InferenceContext<'a> {
         // use a new type variable if we got error type here
         let ty = self.insert_type_vars_shallow(ty);
         if !self.unify(&ty, &expected) {
-            self.result.type_mismatches.insert(
-                pat.into(),
-                TypeMismatch { expected: expected.clone(), actual: ty.clone() },
-            );
+            self.result
+                .type_mismatches
+                .insert(pat.into(), TypeMismatch { expected: expected, actual: ty.clone() });
         }
         self.write_pat_ty(pat, ty.clone());
         ty
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 79cb08d69..6da880b52 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -55,7 +55,7 @@ pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Opti
     let refs_in_target = find_refs_in_mod(ctx, target_module, Some(current_module))?;
     let imported_defs = find_imported_defs(ctx, star)?;
 
-    let target = parent.clone().either(|n| n.syntax().clone(), |n| n.syntax().clone());
+    let target = parent.either(|n| n.syntax().clone(), |n| n.syntax().clone());
     acc.add(
         AssistId("expand_glob_import", AssistKind::RefactorRewrite),
         "Expand glob import",
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index 3aa546980..33a4f8168 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -214,7 +214,7 @@ impl WorkspaceBuildData {
                             acc
                         };
                         let package_build_data =
-                            res.per_package.entry(package_id.repr.clone()).or_default();
+                            res.per_package.entry(package_id.repr).or_default();
                         // cargo_metadata crate returns default (empty) path for
                         // older cargos, which is not absolute, so work around that.
                         if !out_dir.as_str().is_empty() {
@@ -237,13 +237,13 @@ impl WorkspaceBuildData {
                             {
                                 let filename = AbsPathBuf::assert(PathBuf::from(&filename));
                                 let package_build_data =
-                                    res.per_package.entry(package_id.repr.clone()).or_default();
+                                    res.per_package.entry(package_id.repr).or_default();
                                 package_build_data.proc_macro_dylib_path = Some(filename);
                             }
                         }
                     }
                     Message::CompilerMessage(message) => {
-                        progress(message.target.name.clone());
+                        progress(message.target.name);
                     }
                     Message::BuildFinished(_) => {}
                     Message::TextLine(_) => {}
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index a8fee4f08..b8ad08364 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -346,11 +346,8 @@ impl CargoWorkspace {
 
         let workspace_root =
             AbsPathBuf::assert(PathBuf::from(meta.workspace_root.into_os_string()));
-        let build_data_config = BuildDataConfig::new(
-            cargo_toml.to_path_buf(),
-            config.clone(),
-            Arc::new(meta.packages.clone()),
-        );
+        let build_data_config =
+            BuildDataConfig::new(cargo_toml.to_path_buf(), config.clone(), Arc::new(meta.packages));
 
         Ok(CargoWorkspace { packages, targets, workspace_root, build_data_config })
     }