Auto merge of rust-lang#78313 - lcnr:somebody-fold-me, r=nikomatsakis

TypeFoldable: take self by value

Implements rust-lang/compiler-team#371 which is currently still in FCP.

r? `@nikomatsakis`

compiler/rustc_codegen_cranelift/src/abi/mod.rs

@@ -216,7 +216,7 @@ pub(crate) fn get_function_name_and_sig<'tcx>(
     assert!(!inst.substs.needs_infer());
     let fn_sig = tcx.normalize_erasing_late_bound_regions(
         ParamEnv::reveal_all(),
-        &fn_sig_for_fn_abi(tcx, inst),
+        fn_sig_for_fn_abi(tcx, inst),
     );
     if fn_sig.c_variadic && !support_vararg {
         tcx.sess.span_fatal(
@@ -372,7 +372,7 @@ pub(crate) fn codegen_fn_prelude<'tcx>(
         .mir
         .args_iter()
         .map(|local| {
-            let arg_ty = fx.monomorphize(&fx.mir.local_decls[local].ty);
+            let arg_ty = fx.monomorphize(fx.mir.local_decls[local].ty);
 
             // Adapted from https://github.com/rust-lang/rust/blob/145155dc96757002c7b2e9de8489416e2fdbbd57/src/librustc_codegen_llvm/mir/mod.rs#L442-L482
             if Some(local) == fx.mir.spread_arg {
@@ -470,7 +470,7 @@ pub(crate) fn codegen_fn_prelude<'tcx>(
     }
 
     for local in fx.mir.vars_and_temps_iter() {
-        let ty = fx.monomorphize(&fx.mir.local_decls[local].ty);
+        let ty = fx.monomorphize(fx.mir.local_decls[local].ty);
         let layout = fx.layout_of(ty);
 
         let is_ssa = ssa_analyzed[local] == crate::analyze::SsaKind::Ssa;
@@ -492,10 +492,10 @@ pub(crate) fn codegen_terminator_call<'tcx>(
     args: &[Operand<'tcx>],
     destination: Option<(Place<'tcx>, BasicBlock)>,
 ) {
-    let fn_ty = fx.monomorphize(&func.ty(fx.mir, fx.tcx));
+    let fn_ty = fx.monomorphize(func.ty(fx.mir, fx.tcx));
     let fn_sig = fx
         .tcx
-        .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), &fn_ty.fn_sig(fx.tcx));
+        .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), fn_ty.fn_sig(fx.tcx));
 
     let destination = destination.map(|(place, bb)| (codegen_place(fx, place), bb));
 
@@ -711,7 +711,7 @@ pub(crate) fn codegen_drop<'tcx>(
         let drop_fn_ty = drop_fn.ty(fx.tcx, ParamEnv::reveal_all());
         let fn_sig = fx.tcx.normalize_erasing_late_bound_regions(
             ParamEnv::reveal_all(),
-            &drop_fn_ty.fn_sig(fx.tcx),
+            drop_fn_ty.fn_sig(fx.tcx),
         );
         assert_eq!(fn_sig.output(), fx.tcx.mk_unit());
 

compiler/rustc_codegen_cranelift/src/analyze.rs

@@ -17,7 +17,7 @@ pub(crate) fn analyze(fx: &FunctionCx<'_, '_, impl Module>) -> IndexVec<Local, S
         .local_decls
         .iter()
         .map(|local_decl| {
-            let ty = fx.monomorphize(&local_decl.ty);
+            let ty = fx.monomorphize(local_decl.ty);
             if fx.clif_type(ty).is_some() || fx.clif_pair_type(ty).is_some() {
                 SsaKind::Ssa
             } else {

compiler/rustc_codegen_cranelift/src/base.rs

@@ -445,43 +445,43 @@ fn codegen_stmt<'tcx>(
         StatementKind::Assign(to_place_and_rval) => {
             let lval = codegen_place(fx, to_place_and_rval.0);
             let dest_layout = lval.layout();
-            match &to_place_and_rval.1 {
-                Rvalue::Use(operand) => {
+            match to_place_and_rval.1 {
+                Rvalue::Use(ref operand) => {
                     let val = codegen_operand(fx, operand);
                     lval.write_cvalue(fx, val);
                 }
                 Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
-                    let place = codegen_place(fx, *place);
+                    let place = codegen_place(fx, place);
                     let ref_ = place.place_ref(fx, lval.layout());
                     lval.write_cvalue(fx, ref_);
                 }
                 Rvalue::ThreadLocalRef(def_id) => {
-                    let val = crate::constant::codegen_tls_ref(fx, *def_id, lval.layout());
+                    let val = crate::constant::codegen_tls_ref(fx, def_id, lval.layout());
                     lval.write_cvalue(fx, val);
                 }
-                Rvalue::BinaryOp(bin_op, lhs, rhs) => {
+                Rvalue::BinaryOp(bin_op, ref lhs, ref rhs) => {
                     let lhs = codegen_operand(fx, lhs);
                     let rhs = codegen_operand(fx, rhs);
 
-                    let res = crate::num::codegen_binop(fx, *bin_op, lhs, rhs);
+                    let res = crate::num::codegen_binop(fx, bin_op, lhs, rhs);
                     lval.write_cvalue(fx, res);
                 }
-                Rvalue::CheckedBinaryOp(bin_op, lhs, rhs) => {
+                Rvalue::CheckedBinaryOp(bin_op, ref lhs, ref rhs) => {
                     let lhs = codegen_operand(fx, lhs);
                     let rhs = codegen_operand(fx, rhs);
 
                     let res = if !fx.tcx.sess.overflow_checks() {
                         let val =
-                            crate::num::codegen_int_binop(fx, *bin_op, lhs, rhs).load_scalar(fx);
+                            crate::num::codegen_int_binop(fx, bin_op, lhs, rhs).load_scalar(fx);
                         let is_overflow = fx.bcx.ins().iconst(types::I8, 0);
                         CValue::by_val_pair(val, is_overflow, lval.layout())
                     } else {
-                        crate::num::codegen_checked_int_binop(fx, *bin_op, lhs, rhs)
+                        crate::num::codegen_checked_int_binop(fx, bin_op, lhs, rhs)
                     };
 
                     lval.write_cvalue(fx, res);
                 }
-                Rvalue::UnaryOp(un_op, operand) => {
+                Rvalue::UnaryOp(un_op, ref operand) => {
                     let operand = codegen_operand(fx, operand);
                     let layout = operand.layout();
                     let val = operand.load_scalar(fx);
@@ -509,8 +509,8 @@ fn codegen_stmt<'tcx>(
                     };
                     lval.write_cvalue(fx, res);
                 }
-                Rvalue::Cast(CastKind::Pointer(PointerCast::ReifyFnPointer), operand, to_ty) => {
-                    let from_ty = fx.monomorphize(&operand.ty(&fx.mir.local_decls, fx.tcx));
+                Rvalue::Cast(CastKind::Pointer(PointerCast::ReifyFnPointer), ref operand, to_ty) => {
+                    let from_ty = fx.monomorphize(operand.ty(&fx.mir.local_decls, fx.tcx));
                     let to_layout = fx.layout_of(fx.monomorphize(to_ty));
                     match *from_ty.kind() {
                         ty::FnDef(def_id, substs) => {
@@ -530,14 +530,14 @@ fn codegen_stmt<'tcx>(
                         _ => bug!("Trying to ReifyFnPointer on non FnDef {:?}", from_ty),
                     }
                 }
-                Rvalue::Cast(CastKind::Pointer(PointerCast::UnsafeFnPointer), operand, to_ty)
-                | Rvalue::Cast(CastKind::Pointer(PointerCast::MutToConstPointer), operand, to_ty)
-                | Rvalue::Cast(CastKind::Pointer(PointerCast::ArrayToPointer), operand, to_ty) => {
+                Rvalue::Cast(CastKind::Pointer(PointerCast::UnsafeFnPointer), ref operand, to_ty)
+                | Rvalue::Cast(CastKind::Pointer(PointerCast::MutToConstPointer), ref operand, to_ty)
+                | Rvalue::Cast(CastKind::Pointer(PointerCast::ArrayToPointer), ref operand, to_ty) => {
                     let to_layout = fx.layout_of(fx.monomorphize(to_ty));
                     let operand = codegen_operand(fx, operand);
                     lval.write_cvalue(fx, operand.cast_pointer_to(to_layout));
                 }
-                Rvalue::Cast(CastKind::Misc, operand, to_ty) => {
+                Rvalue::Cast(CastKind::Misc, ref operand, to_ty) => {
                     let operand = codegen_operand(fx, operand);
                     let from_ty = operand.layout().ty;
                     let to_ty = fx.monomorphize(to_ty);
@@ -577,12 +577,12 @@ fn codegen_stmt<'tcx>(
 
                         use rustc_target::abi::{Int, TagEncoding, Variants};
 
-                        match &operand.layout().variants {
+                        match operand.layout().variants {
                             Variants::Single { index } => {
                                 let discr = operand
                                     .layout()
                                     .ty
-                                    .discriminant_for_variant(fx.tcx, *index)
+                                    .discriminant_for_variant(fx.tcx, index)
                                     .unwrap();
                                 let discr = if discr.ty.is_signed() {
                                     fx.layout_of(discr.ty).size.sign_extend(discr.val)
@@ -595,7 +595,7 @@ fn codegen_stmt<'tcx>(
                                 lval.write_cvalue(fx, discr);
                             }
                             Variants::Multiple {
-                                tag,
+                                ref tag,
                                 tag_field,
                                 tag_encoding: TagEncoding::Direct,
                                 variants: _,
@@ -604,7 +604,7 @@ fn codegen_stmt<'tcx>(
 
                                 // Read the tag/niche-encoded discriminant from memory.
                                 let encoded_discr =
-                                    operand.value_field(fx, mir::Field::new(*tag_field));
+                                    operand.value_field(fx, mir::Field::new(tag_field));
                                 let encoded_discr = encoded_discr.load_scalar(fx);
 
                                 // Decode the discriminant (specifically if it's niche-encoded).
@@ -634,7 +634,7 @@ fn codegen_stmt<'tcx>(
                 }
                 Rvalue::Cast(
                     CastKind::Pointer(PointerCast::ClosureFnPointer(_)),
-                    operand,
+                    ref operand,
                     _to_ty,
                 ) => {
                     let operand = codegen_operand(fx, operand);
@@ -654,18 +654,18 @@ fn codegen_stmt<'tcx>(
                         _ => bug!("{} cannot be cast to a fn ptr", operand.layout().ty),
                     }
                 }
-                Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), operand, _to_ty) => {
+                Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), ref operand, _to_ty) => {
                     let operand = codegen_operand(fx, operand);
                     operand.unsize_value(fx, lval);
                 }
                 Rvalue::Discriminant(place) => {
-                    let place = codegen_place(fx, *place);
+                    let place = codegen_place(fx, place);
                     let value = place.to_cvalue(fx);
                     let discr =
                         crate::discriminant::codegen_get_discriminant(fx, value, dest_layout);
                     lval.write_cvalue(fx, discr);
                 }
-                Rvalue::Repeat(operand, times) => {
+                Rvalue::Repeat(ref operand, times) => {
                     let operand = codegen_operand(fx, operand);
                     let times = fx
                         .monomorphize(times)
@@ -704,7 +704,7 @@ fn codegen_stmt<'tcx>(
                     }
                 }
                 Rvalue::Len(place) => {
-                    let place = codegen_place(fx, *place);
+                    let place = codegen_place(fx, place);
                     let usize_layout = fx.layout_of(fx.tcx.types.usize);
                     let len = codegen_array_len(fx, place);
                     lval.write_cvalue(fx, CValue::by_val(len, usize_layout));
@@ -749,7 +749,7 @@ fn codegen_stmt<'tcx>(
                         CValue::const_val(fx, fx.layout_of(fx.tcx.types.usize), ty_size.into());
                     lval.write_cvalue(fx, val);
                 }
-                Rvalue::Aggregate(kind, operands) => match **kind {
+                Rvalue::Aggregate(ref kind, ref operands) => match kind.as_ref() {
                     AggregateKind::Array(_ty) => {
                         for (i, operand) in operands.iter().enumerate() {
                             let operand = codegen_operand(fx, operand);
@@ -877,8 +877,7 @@ fn codegen_array_len<'tcx>(
     match *place.layout().ty.kind() {
         ty::Array(_elem_ty, len) => {
             let len = fx
-                .monomorphize(&len)
-                .eval(fx.tcx, ParamEnv::reveal_all())
+                .monomorphize(len)
                 .eval_usize(fx.tcx, ParamEnv::reveal_all()) as i64;
             fx.bcx.ins().iconst(fx.pointer_type, len)
         }

compiler/rustc_codegen_cranelift/src/common.rs

@@ -357,7 +357,7 @@ impl<'tcx, M: Module> HasTargetSpec for FunctionCx<'_, 'tcx, M> {
 }
 
 impl<'tcx, M: Module> FunctionCx<'_, 'tcx, M> {
-    pub(crate) fn monomorphize<T>(&self, value: &T) -> T
+    pub(crate) fn monomorphize<T>(&self, value: T) -> T
     where
         T: TypeFoldable<'tcx> + Copy,
     {

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -38,7 +38,7 @@ impl ConstantCx {
 
 pub(crate) fn check_constants(fx: &mut FunctionCx<'_, '_, impl Module>) {
     for constant in &fx.mir.required_consts {
-        let const_ = fx.monomorphize(&constant.literal);
+        let const_ = fx.monomorphize(constant.literal);
         match const_.val {
             ConstKind::Value(_) => {}
             ConstKind::Unevaluated(def, ref substs, promoted) => {
@@ -110,7 +110,7 @@ pub(crate) fn codegen_constant<'tcx>(
     fx: &mut FunctionCx<'_, 'tcx, impl Module>,
     constant: &Constant<'tcx>,
 ) -> CValue<'tcx> {
-    let const_ = fx.monomorphize(&constant.literal);
+    let const_ = fx.monomorphize(constant.literal);
     let const_val = match const_.val {
         ConstKind::Value(const_val) => const_val,
         ConstKind::Unevaluated(def, ref substs, promoted) if fx.tcx.is_static(def.did) => {
@@ -466,7 +466,7 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
     match operand {
         Operand::Copy(_) | Operand::Move(_) => None,
         Operand::Constant(const_) => Some(
-            fx.monomorphize(&const_.literal)
+            fx.monomorphize(const_.literal)
                 .eval(fx.tcx, ParamEnv::reveal_all()),
         ),
     }

compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs

@@ -365,7 +365,7 @@ impl<'tcx> DebugContext<'tcx> {
                 let ty = self.tcx.subst_and_normalize_erasing_regions(
                     instance.substs,
                     ty::ParamEnv::reveal_all(),
-                    &mir.local_decls[local].ty,
+                    mir.local_decls[local].ty,
                 );
                 let var_id = self.define_local(entry_id, format!("{:?}", local), ty);
 

compiler/rustc_codegen_cranelift/src/main_shim.rs

@@ -50,7 +50,7 @@ pub(crate) fn maybe_create_entry_wrapper(
         // late-bound regions, since late-bound
         // regions must appear in the argument
         // listing.
-        let main_ret_ty = tcx.erase_regions(&main_ret_ty.no_bound_vars().unwrap());
+        let main_ret_ty = tcx.erase_regions(main_ret_ty.no_bound_vars().unwrap());
 
         let cmain_sig = Signature {
             params: vec![

compiler/rustc_codegen_cranelift/src/pretty_clif.rs

@@ -80,7 +80,7 @@ impl CommentWriter {
                     "sig {:?}",
                     tcx.normalize_erasing_late_bound_regions(
                         ParamEnv::reveal_all(),
-                        &crate::abi::fn_sig_for_fn_abi(tcx, instance)
+                        crate::abi::fn_sig_for_fn_abi(tcx, instance)
                     )
                 ),
                 String::new(),

compiler/rustc_codegen_cranelift/src/value_and_place.rs

@@ -455,7 +455,7 @@ impl<'tcx> CPlace<'tcx> {
             from_ty: Ty<'tcx>,
             to_ty: Ty<'tcx>,
         ) {
-            match (&from_ty.kind(), &to_ty.kind()) {
+            match (from_ty.kind(), to_ty.kind()) {
                 (ty::Ref(_, a, _), ty::Ref(_, b, _))
                 | (
                     ty::RawPtr(TypeAndMut { ty: a, mutbl: _ }),
@@ -466,11 +466,11 @@ impl<'tcx> CPlace<'tcx> {
                 (ty::FnPtr(_), ty::FnPtr(_)) => {
                     let from_sig = fx.tcx.normalize_erasing_late_bound_regions(
                         ParamEnv::reveal_all(),
-                        &from_ty.fn_sig(fx.tcx),
+                        from_ty.fn_sig(fx.tcx),
                     );
                     let to_sig = fx.tcx.normalize_erasing_late_bound_regions(
                         ParamEnv::reveal_all(),
-                        &to_ty.fn_sig(fx.tcx),
+                        to_ty.fn_sig(fx.tcx),
                     );
                     assert_eq!(
                         from_sig, to_sig,
@@ -479,7 +479,7 @@ impl<'tcx> CPlace<'tcx> {
                     );
                     // fn(&T) -> for<'l> fn(&'l T) is allowed
                 }
-                (ty::Dynamic(from_traits, _), ty::Dynamic(to_traits, _)) => {
+                (&ty::Dynamic(from_traits, _), &ty::Dynamic(to_traits, _)) => {
                     let from_traits = fx
                         .tcx
                         .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), from_traits);

compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs

@@ -92,7 +92,7 @@ fn make_mir_scope(
             let callee = cx.tcx.subst_and_normalize_erasing_regions(
                 instance.substs,
                 ty::ParamEnv::reveal_all(),
-                &callee,
+                callee,
             );
             let callee_fn_abi = FnAbi::of_instance(cx, callee, &[]);
             cx.dbg_scope_fn(callee, &callee_fn_abi, None)

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -189,7 +189,7 @@ impl TypeMap<'ll, 'tcx> {
         // something that provides more than the 64 bits of the DefaultHasher.
         let mut hasher = StableHasher::new();
         let mut hcx = cx.tcx.create_stable_hashing_context();
-        let type_ = cx.tcx.erase_regions(&type_);
+        let type_ = cx.tcx.erase_regions(type_);
         hcx.while_hashing_spans(false, |hcx| {
             hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
                 type_.hash_stable(hcx, &mut hasher);
@@ -427,7 +427,7 @@ fn subroutine_type_metadata(
     span: Span,
 ) -> MetadataCreationResult<'ll> {
     let signature =
-        cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &signature);
+        cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), signature);
 
     let signature_metadata: Vec<_> = iter::once(
         // return type

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -501,7 +501,7 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                     let impl_self_ty = cx.tcx.subst_and_normalize_erasing_regions(
                         instance.substs,
                         ty::ParamEnv::reveal_all(),
-                        &cx.tcx.type_of(impl_def_id),
+                        cx.tcx.type_of(impl_def_id),
                     );
 
                     // Only "class" methods are generally understood by LLVM,

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -91,7 +91,7 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         };
 
         let sig = callee_ty.fn_sig(tcx);
-        let sig = tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
+        let sig = tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), sig);
         let arg_tys = sig.inputs();
         let ret_ty = sig.output();
         let name = tcx.item_name(def_id);
@@ -777,8 +777,8 @@ fn generic_simd_intrinsic(
     }
 
     let tcx = bx.tcx();
-    let sig = tcx
-        .normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &callee_ty.fn_sig(tcx));
+    let sig =
+        tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), callee_ty.fn_sig(tcx));
     let arg_tys = sig.inputs();
     let name_str = &*name.as_str();
 

compiler/rustc_codegen_llvm/src/type_of.rs

@@ -252,7 +252,7 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
 
         // Make sure lifetimes are erased, to avoid generating distinct LLVM
         // types for Rust types that only differ in the choice of lifetimes.
-        let normal_ty = cx.tcx.erase_regions(&self.ty);
+        let normal_ty = cx.tcx.erase_regions(self.ty);
 
         let mut defer = None;
         let llty = if self.ty != normal_ty {