Auto merge of rust-lang#16294 - matthiaskrgr:less_alloc, r=Veykril

minor: some minor clippy::perf fixes

can be read commit by commit if you want 🤷

Author: bors

crates/hir-def/src/body/lower.rs

@@ -1610,7 +1610,7 @@ impl ExprCollector<'_> {
                 |name| self.alloc_expr_desugared(Expr::Path(Path::from(name))),
                 |name, span| {
                     if let Some(span) = span {
-                        mappings.push((span, name.clone()))
+                        mappings.push((span, name))
                     }
                 },
             ),

crates/hir-def/src/nameres/collector.rs

@@ -1397,7 +1397,7 @@ impl DefCollector<'_> {
                     always!(krate == loc.def.krate);
                     DefDiagnostic::unresolved_proc_macro(module_id, loc.kind.clone(), loc.def.krate)
                 }
-                _ => DefDiagnostic::macro_error(module_id, loc.kind.clone(), err.to_string()),
+                _ => DefDiagnostic::macro_error(module_id, loc.kind, err.to_string()),
             };
 
             self.def_map.diagnostics.push(diag);

crates/hir-ty/src/display.rs

@@ -609,7 +609,7 @@ fn render_const_scalar(
                 }
                 hir_def::AdtId::EnumId(e) => {
                     let Some((var_id, var_layout)) =
-                        detect_variant_from_bytes(&layout, f.db, trait_env.clone(), b, e)
+                        detect_variant_from_bytes(&layout, f.db, trait_env, b, e)
                     else {
                         return f.write_str("<failed-to-detect-variant>");
                     };

crates/hir-ty/src/infer.rs

@@ -738,7 +738,7 @@ impl<'a> InferenceContext<'a> {
         result.tuple_field_access_types = tuple_field_accesses_rev
             .into_iter()
             .enumerate()
-            .map(|(idx, subst)| (TupleId(idx as u32), table.resolve_completely(subst.clone())))
+            .map(|(idx, subst)| (TupleId(idx as u32), table.resolve_completely(subst)))
             .collect();
         result
     }

crates/hir-ty/src/infer/closure.rs

@@ -130,7 +130,7 @@ impl HirPlace {
                 ctx.owner.module(ctx.db.upcast()).krate(),
             );
         }
-        ty.clone()
+        ty
     }
 
     fn capture_kind_of_truncated_place(
@@ -245,7 +245,7 @@ pub(crate) struct CapturedItemWithoutTy {
 
 impl CapturedItemWithoutTy {
     fn with_ty(self, ctx: &mut InferenceContext<'_>) -> CapturedItem {
-        let ty = self.place.ty(ctx).clone();
+        let ty = self.place.ty(ctx);
         let ty = match &self.kind {
             CaptureKind::ByValue => ty,
             CaptureKind::ByRef(bk) => {
@@ -396,7 +396,7 @@ impl InferenceContext<'_> {
 
     fn consume_place(&mut self, place: HirPlace, span: MirSpan) {
         if self.is_upvar(&place) {
-            let ty = place.ty(self).clone();
+            let ty = place.ty(self);
             let kind = if self.is_ty_copy(ty) {
                 CaptureKind::ByRef(BorrowKind::Shared)
             } else {

crates/hir-ty/src/infer/expr.rs

@@ -978,7 +978,7 @@ impl InferenceContext<'_> {
                 .push(callee_ty.clone())
                 .push(TyBuilder::tuple_with(params.iter().cloned()))
                 .build();
-            self.write_method_resolution(tgt_expr, func, subst.clone());
+            self.write_method_resolution(tgt_expr, func, subst);
         }
     }
 

crates/hir-ty/src/infer/pat.rs

@@ -233,7 +233,6 @@ impl InferenceContext<'_> {
         };
         let mut expectations_iter = expectations
             .iter()
-            .cloned()
             .map(|a| a.assert_ty_ref(Interner).clone())
             .chain(repeat_with(|| self.table.new_type_var()));
 
@@ -336,7 +335,7 @@ impl InferenceContext<'_> {
             &Pat::Lit(expr) => {
                 // Don't emit type mismatches again, the expression lowering already did that.
                 let ty = self.infer_lit_pat(expr, &expected);
-                self.write_pat_ty(pat, ty.clone());
+                self.write_pat_ty(pat, ty);
                 return self.pat_ty_after_adjustment(pat);
             }
             Pat::Box { inner } => match self.resolve_boxed_box() {

crates/hir-ty/src/layout.rs

@@ -164,7 +164,7 @@ fn layout_of_simd_ty(
     };
 
     // Compute the ABI of the element type:
-    let e_ly = db.layout_of_ty(e_ty, env.clone())?;
+    let e_ly = db.layout_of_ty(e_ty, env)?;
     let Abi::Scalar(e_abi) = e_ly.abi else {
         return Err(LayoutError::Unknown);
     };
@@ -204,17 +204,17 @@ pub fn layout_of_ty_query(
     };
     let cx = LayoutCx { target: &target };
     let dl = &*cx.current_data_layout();
-    let ty = normalize(db, trait_env.clone(), ty.clone());
+    let ty = normalize(db, trait_env.clone(), ty);
     let result = match ty.kind(Interner) {
         TyKind::Adt(AdtId(def), subst) => {
             if let hir_def::AdtId::StructId(s) = def {
                 let data = db.struct_data(*s);
                 let repr = data.repr.unwrap_or_default();
                 if repr.simd() {
-                    return layout_of_simd_ty(db, *s, subst, trait_env.clone(), &target);
+                    return layout_of_simd_ty(db, *s, subst, trait_env, &target);
                 }
             };
-            return db.layout_of_adt(*def, subst.clone(), trait_env.clone());
+            return db.layout_of_adt(*def, subst.clone(), trait_env);
         }
         TyKind::Scalar(s) => match s {
             chalk_ir::Scalar::Bool => Layout::scalar(
@@ -280,7 +280,7 @@ pub fn layout_of_ty_query(
         }
         TyKind::Array(element, count) => {
             let count = try_const_usize(db, &count).ok_or(LayoutError::HasErrorConst)? as u64;
-            let element = db.layout_of_ty(element.clone(), trait_env.clone())?;
+            let element = db.layout_of_ty(element.clone(), trait_env)?;
             let size = element.size.checked_mul(count, dl).ok_or(LayoutError::SizeOverflow)?;
 
             let abi = if count != 0 && matches!(element.abi, Abi::Uninhabited) {
@@ -303,7 +303,7 @@ pub fn layout_of_ty_query(
             }
         }
         TyKind::Slice(element) => {
-            let element = db.layout_of_ty(element.clone(), trait_env.clone())?;
+            let element = db.layout_of_ty(element.clone(), trait_env)?;
             Layout {
                 variants: Variants::Single { index: struct_variant_idx() },
                 fields: FieldsShape::Array { stride: element.size, count: 0 },
@@ -345,7 +345,7 @@ pub fn layout_of_ty_query(
                 }))
                 .intern(Interner);
             }
-            unsized_part = normalize(db, trait_env.clone(), unsized_part);
+            unsized_part = normalize(db, trait_env, unsized_part);
             let metadata = match unsized_part.kind(Interner) {
                 TyKind::Slice(_) | TyKind::Str => {
                     scalar_unit(dl, Primitive::Int(dl.ptr_sized_integer(), false))
@@ -384,7 +384,7 @@ pub fn layout_of_ty_query(
             match impl_trait_id {
                 crate::ImplTraitId::ReturnTypeImplTrait(func, idx) => {
                     let infer = db.infer(func.into());
-                    return db.layout_of_ty(infer.type_of_rpit[idx].clone(), trait_env.clone());
+                    return db.layout_of_ty(infer.type_of_rpit[idx].clone(), trait_env);
                 }
                 crate::ImplTraitId::AsyncBlockTypeImplTrait(_, _) => {
                     return Err(LayoutError::NotImplemented)

crates/hir-ty/src/method_resolution.rs

@@ -1350,7 +1350,7 @@ pub(crate) fn resolve_indexing_op(
     ty: Canonical<Ty>,
     index_trait: TraitId,
 ) -> Option<ReceiverAdjustments> {
-    let mut table = InferenceTable::new(db, env.clone());
+    let mut table = InferenceTable::new(db, env);
     let ty = table.instantiate_canonical(ty);
     let deref_chain = autoderef_method_receiver(&mut table, ty);
     for (ty, adj) in deref_chain {

crates/hir-ty/src/mir/eval.rs

@@ -386,7 +386,7 @@ impl MirEvalError {
                 write!(
                     f,
                     "Layout for type `{}` is not available due {err:?}",
-                    ty.display(db).with_closure_style(ClosureStyle::ClosureWithId).to_string()
+                    ty.display(db).with_closure_style(ClosureStyle::ClosureWithId)
                 )?;
             }
             MirEvalError::MirLowerError(func, err) => {
@@ -1533,7 +1533,7 @@ impl Evaluator<'_> {
                 }
             },
             TyKind::Dyn(_) => {
-                let vtable = self.vtable_map.id(current_ty.clone());
+                let vtable = self.vtable_map.id(current_ty);
                 let mut r = Vec::with_capacity(16);
                 let addr = addr.get(self)?;
                 r.extend(addr.iter().copied());