Bunch of clippy fixes

Author: bjorn3

src/abi/mod.rs

@@ -85,7 +85,7 @@ pub(crate) fn get_function_sig<'tcx>(
     clif_sig_from_fn_abi(
         tcx,
         default_call_conv,
-        &FullyMonomorphizedLayoutCx(tcx).fn_abi_of_instance(inst, ty::List::empty()),
+        FullyMonomorphizedLayoutCx(tcx).fn_abi_of_instance(inst, ty::List::empty()),
     )
 }
 
@@ -114,7 +114,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
     /// Instance must be monomorphized
     pub(crate) fn get_function_ref(&mut self, inst: Instance<'tcx>) -> FuncRef {
         let func_id = import_function(self.tcx, self.module, inst);
-        let func_ref = self.module.declare_func_in_func(func_id, &mut self.bcx.func);
+        let func_ref = self.module.declare_func_in_func(func_id, self.bcx.func);
 
         if self.clif_comments.enabled() {
             self.add_comment(func_ref, format!("{:?}", inst));
@@ -185,7 +185,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
     ) -> &[Value] {
         let sig = Signature { params, returns, call_conv: self.target_config.default_call_conv };
         let func_id = self.module.declare_function(name, Linkage::Import, &sig).unwrap();
-        let func_ref = self.module.declare_func_in_func(func_id, &mut self.bcx.func);
+        let func_ref = self.module.declare_func_in_func(func_id, self.bcx.func);
         let call_inst = self.bcx.ins().call(func_ref, args);
         if self.clif_comments.enabled() {
             self.add_comment(func_ref, format!("{:?}", name));
@@ -419,7 +419,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
         if fx.tcx.symbol_name(instance).name.starts_with("llvm.") {
             crate::intrinsics::codegen_llvm_intrinsic_call(
                 fx,
-                &fx.tcx.symbol_name(instance).name,
+                fx.tcx.symbol_name(instance).name,
                 args,
                 ret_place,
                 target,
@@ -534,7 +534,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
             }
 
             let (ptr, method) = crate::vtable::get_ptr_and_method_ref(fx, args[0].value, idx);
-            let sig = clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, &fn_abi);
+            let sig = clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, fn_abi);
             let sig = fx.bcx.import_signature(sig);
 
             (CallTarget::Indirect(sig, method), Some(ptr.get_addr(fx)))
@@ -554,7 +554,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
             }
 
             let func = func.load_scalar(fx);
-            let sig = clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, &fn_abi);
+            let sig = clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, fn_abi);
             let sig = fx.bcx.import_signature(sig);
 
             (CallTarget::Indirect(sig, func), None)
@@ -564,7 +564,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
     self::returning::codegen_with_call_return_arg(fx, &fn_abi.ret, ret_place, |fx, return_ptr| {
         let mut call_args = return_ptr
             .into_iter()
-            .chain(first_arg_override.into_iter())
+            .chain(first_arg_override)
             .chain(
                 args.into_iter()
                     .enumerate()
@@ -577,7 +577,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
 
         // FIXME: Find a cleaner way to support varargs.
         if fn_abi.c_variadic {
-            adjust_call_for_c_variadic(fx, &fn_abi, source_info, func_ref, &mut call_args);
+            adjust_call_for_c_variadic(fx, fn_abi, source_info, func_ref, &mut call_args);
         }
 
         if fx.clif_comments.enabled() {
@@ -739,7 +739,7 @@ pub(crate) fn codegen_drop<'tcx>(
                 let fn_abi = FullyMonomorphizedLayoutCx(fx.tcx)
                     .fn_abi_of_instance(virtual_drop, ty::List::empty());
 
-                let sig = clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, &fn_abi);
+                let sig = clif_sig_from_fn_abi(fx.tcx, fx.target_config.default_call_conv, fn_abi);
                 let sig = fx.bcx.import_signature(sig);
                 codegen_call_with_unwind_action(
                     fx,
@@ -767,9 +767,12 @@ pub(crate) fn codegen_drop<'tcx>(
                 if drop_instance.def.requires_caller_location(fx.tcx) {
                     // Pass the caller location for `#[track_caller]`.
                     let caller_location = fx.get_caller_location(source_info);
-                    call_args.extend(
-                        adjust_arg_for_abi(fx, caller_location, &fn_abi.args[1], false).into_iter(),
-                    );
+                    call_args.extend(adjust_arg_for_abi(
+                        fx,
+                        caller_location,
+                        &fn_abi.args[1],
+                        false,
+                    ));
                 }
 
                 let func_ref = fx.get_function_ref(drop_instance);
@@ -816,9 +819,9 @@ pub(crate) fn codegen_call_with_unwind_action(
     match unwind {
         UnwindAction::Continue | UnwindAction::Unreachable => {
             let call_inst = match func_ref {
-                CallTarget::Direct(func_ref) => fx.bcx.ins().call(func_ref, &call_args),
+                CallTarget::Direct(func_ref) => fx.bcx.ins().call(func_ref, call_args),
                 CallTarget::Indirect(sig, func_ptr) => {
-                    fx.bcx.ins().call_indirect(sig, func_ptr, &call_args)
+                    fx.bcx.ins().call_indirect(sig, func_ptr, call_args)
                 }
             };
 
@@ -866,10 +869,10 @@ pub(crate) fn codegen_call_with_unwind_action(
 
             match func_ref {
                 CallTarget::Direct(func_ref) => {
-                    fx.bcx.ins().try_call(func_ref, &call_args, exception_table);
+                    fx.bcx.ins().try_call(func_ref, call_args, exception_table);
                 }
                 CallTarget::Indirect(_sig, func_ptr) => {
-                    fx.bcx.ins().try_call_indirect(func_ptr, &call_args, exception_table);
+                    fx.bcx.ins().try_call_indirect(func_ptr, call_args, exception_table);
                 }
             }
 

src/abi/pass_mode.rs

@@ -209,12 +209,7 @@ pub(super) fn to_casted_value<'tcx>(
     cast_target_to_abi_params(cast)
         .into_iter()
         .map(|(offset, param)| {
-            let val = ptr.offset_i64(fx, offset.bytes() as i64).load(
-                fx,
-                param.value_type,
-                MemFlags::new(),
-            );
-            val
+            ptr.offset_i64(fx, offset.bytes() as i64).load(fx, param.value_type, MemFlags::new())
         })
         .collect()
 }

src/base.rs

@@ -266,12 +266,12 @@ fn verify_func(tcx: TyCtxt<'_>, writer: &crate::pretty_clif::CommentWriter, func
 
     tcx.prof.generic_activity("verify clif ir").run(|| {
         let flags = cranelift_codegen::settings::Flags::new(cranelift_codegen::settings::builder());
-        match cranelift_codegen::verify_function(&func, &flags) {
+        match cranelift_codegen::verify_function(func, &flags) {
             Ok(_) => {}
             Err(err) => {
                 tcx.dcx().err(format!("{:?}", err));
                 let pretty_error = cranelift_codegen::print_errors::pretty_verifier_error(
-                    &func,
+                    func,
                     Some(Box::new(writer)),
                     err,
                 );
@@ -554,7 +554,7 @@ fn codegen_fn_body(fx: &mut FunctionCx<'_, '_, '_>, start_block: Block) {
                     template,
                     operands,
                     *options,
-                    targets.get(0).copied(),
+                    targets.first().copied(),
                 );
             }
             TerminatorKind::UnwindTerminate(reason) => {
@@ -1131,7 +1131,7 @@ fn codegen_panic_inner<'tcx>(
         call_conv: fx.target_config.default_call_conv,
     };
     let func_id = fx.module.declare_function(symbol_name, Linkage::Import, &sig).unwrap();
-    let func_ref = fx.module.declare_func_in_func(func_id, &mut fx.bcx.func);
+    let func_ref = fx.module.declare_func_in_func(func_id, fx.bcx.func);
     if fx.clif_comments.enabled() {
         fx.add_comment(func_ref, format!("{:?}", symbol_name));
     }
@@ -1141,7 +1141,7 @@ fn codegen_panic_inner<'tcx>(
         fx.add_comment(nop_inst, format!("panic {}", symbol_name));
     }
 
-    codegen_call_with_unwind_action(fx, span, CallTarget::Direct(func_ref), unwind, &args, None);
+    codegen_call_with_unwind_action(fx, span, CallTarget::Direct(func_ref), unwind, args, None);
 
     fx.bcx.ins().trap(TrapCode::user(1 /* unreachable */).unwrap());
 }

src/codegen_f16_f128.rs

@@ -75,8 +75,7 @@ pub(crate) fn fcmp(fx: &mut FunctionCx<'_, '_, '_>, cc: FloatCC, lhs: Value, rhs
                 &[lhs, rhs],
             )[0];
             let zero = fx.bcx.ins().iconst(CMP_RESULT_TY, 0);
-            let res = fx.bcx.ins().icmp(int_cc, res, zero);
-            res
+            fx.bcx.ins().icmp(int_cc, res, zero)
         }
         _ => unreachable!("{ty:?}"),
     }

src/common.rs

@@ -257,7 +257,7 @@ pub(crate) fn create_wrapper_function(
             .map(|param| func.dfg.append_block_param(block, param.value_type))
             .collect::<Vec<Value>>();
 
-        let callee_func_ref = module.declare_func_in_func(callee_func_id, &mut bcx.func);
+        let callee_func_ref = module.declare_func_in_func(callee_func_id, bcx.func);
         let call_inst = bcx.ins().call(callee_func_ref, &args);
         let results = bcx.inst_results(call_inst).to_vec(); // Clone to prevent borrow error
 
@@ -374,7 +374,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
 
     pub(crate) fn create_stack_slot(&mut self, size: u32, align: u32) -> Pointer {
         assert!(
-            size % align == 0,
+            size.is_multiple_of(align),
             "size must be a multiple of alignment (size={size}, align={align})"
         );
 
@@ -384,7 +384,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
                 kind: StackSlotKind::ExplicitSlot,
                 // FIXME Don't force the size to a multiple of <abi_align> bytes once Cranelift gets
                 // a way to specify stack slot alignment.
-                size: (size + abi_align - 1) / abi_align * abi_align,
+                size: size.div_ceil(abi_align) * abi_align,
                 align_shift: 4,
             });
             Pointer::stack_slot(stack_slot)

src/constant.rs

@@ -65,7 +65,7 @@ pub(crate) fn codegen_tls_ref<'tcx>(
             // For a declaration the stated mutability doesn't matter.
             false,
         );
-        let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+        let local_data_id = fx.module.declare_data_in_func(data_id, fx.bcx.func);
         if fx.clif_comments.enabled() {
             fx.add_comment(local_data_id, format!("tls {:?}", def_id));
         }
@@ -111,7 +111,7 @@ pub(crate) fn codegen_const_value<'tcx>(
         ConstValue::Scalar(x) => match x {
             Scalar::Int(int) => {
                 if fx.clif_type(layout.ty).is_some() {
-                    return CValue::const_val(fx, layout, int);
+                    CValue::const_val(fx, layout, int)
                 } else {
                     let raw_val = int.size().truncate(int.to_bits(int.size()));
                     let val = match int.size().bytes() {
@@ -150,7 +150,7 @@ pub(crate) fn codegen_const_value<'tcx>(
                                 alloc.inner().mutability,
                             );
                             let local_data_id =
-                                fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+                                fx.module.declare_data_in_func(data_id, fx.bcx.func);
                             if fx.clif_comments.enabled() {
                                 fx.add_comment(local_data_id, format!("{:?}", alloc_id));
                             }
@@ -159,8 +159,7 @@ pub(crate) fn codegen_const_value<'tcx>(
                     }
                     GlobalAlloc::Function { instance, .. } => {
                         let func_id = crate::abi::import_function(fx.tcx, fx.module, instance);
-                        let local_func_id =
-                            fx.module.declare_func_in_func(func_id, &mut fx.bcx.func);
+                        let local_func_id = fx.module.declare_func_in_func(func_id, fx.bcx.func);
                         fx.bcx.ins().func_addr(fx.pointer_type, local_func_id)
                     }
                     GlobalAlloc::VTable(ty, dyn_ty) => {
@@ -173,8 +172,7 @@ pub(crate) fn codegen_const_value<'tcx>(
                                 fx.tcx.instantiate_bound_regions_with_erased(principal)
                             }),
                         );
-                        let local_data_id =
-                            fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+                        let local_data_id = fx.module.declare_data_in_func(data_id, fx.bcx.func);
                         fx.bcx.ins().symbol_value(fx.pointer_type, local_data_id)
                     }
                     GlobalAlloc::TypeId { .. } => {
@@ -191,8 +189,7 @@ pub(crate) fn codegen_const_value<'tcx>(
                             // For a declaration the stated mutability doesn't matter.
                             false,
                         );
-                        let local_data_id =
-                            fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+                        let local_data_id = fx.module.declare_data_in_func(data_id, fx.bcx.func);
                         if fx.clif_comments.enabled() {
                             fx.add_comment(local_data_id, format!("{:?}", def_id));
                         }
@@ -236,7 +233,7 @@ fn pointer_for_allocation<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, alloc_id: All
     let data_id =
         data_id_for_alloc_id(&mut fx.constants_cx, fx.module, alloc_id, alloc.inner().mutability);
 
-    let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+    let local_data_id = fx.module.declare_data_in_func(data_id, fx.bcx.func);
     if fx.clif_comments.enabled() {
         fx.add_comment(local_data_id, format!("{:?}", alloc_id));
     }
@@ -354,7 +351,7 @@ fn data_id_for_static(
         Linkage::Import
     };
 
-    let data_id = match module.declare_data(
+    match module.declare_data(
         symbol_name,
         linkage,
         definition_writable,
@@ -365,9 +362,7 @@ fn data_id_for_static(
             "attempt to declare `{symbol_name}` as static, but it was already declared as function"
         )),
         Err(err) => Err::<_, _>(err).unwrap(),
-    };
-
-    data_id
+    }
 }
 
 fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut ConstantCx) {

src/debuginfo/emit.rs

@@ -222,12 +222,12 @@ impl Writer for WriterRelocate {
                 gimli::DW_EH_PE_absptr => {
                     self.relocs.push(DebugReloc {
                         offset: self.len() as u32,
-                        size: size.into(),
+                        size,
                         name: DebugRelocName::Symbol(symbol),
                         addend,
                         kind: object::RelocationKind::Absolute,
                     });
-                    self.write_udata(0, size.into())
+                    self.write_udata(0, size)
                 }
                 _ => Err(gimli::write::Error::UnsupportedPointerEncoding(eh_pe)),
             },

src/debuginfo/gcc_except_table.rs

@@ -41,8 +41,7 @@ impl GccExceptTable {
                     + self.call_sites.encoded_size()
                     + self.actions.encoded_size()
                     + type_info_padding)
-                    % 4
-                    == 0
+                    .is_multiple_of(4)
             };
 
             let mut type_info_padding = 0;
@@ -69,9 +68,9 @@ impl GccExceptTable {
             // In this case we calculated the expected padding amount and used it to write the
             // classInfoOffset field. Assert that the expected value matched the actual value to catch
             // any inconsistency.
-            assert!(w.len() % 4 == 0, "type_info must be aligned to 4 bytes");
+            assert!(w.len().is_multiple_of(4), "type_info must be aligned to 4 bytes");
         } else {
-            while w.len() % 4 != 0 {
+            while !w.len().is_multiple_of(4) {
                 w.write_u8(0)?;
             }
         }
@@ -82,7 +81,7 @@ impl GccExceptTable {
         // exception specs (unused for rust)
 
         // align to 4 bytes
-        while w.len() % 4 != 0 {
+        while !w.len().is_multiple_of(4) {
             w.write_u8(0)?;
         }
 

src/debuginfo/types.rs

@@ -56,7 +56,7 @@ impl DebugContext {
             // ty::FnDef(..) | ty::FnPtr(..)
             // ty::Closure(..)
             // ty::Adt(def, ..)
-            ty::Tuple(components) => self.tuple_type(tcx, type_dbg, ty, *components),
+            ty::Tuple(components) => self.tuple_type(tcx, type_dbg, ty, components),
             // ty::Param(_)
             // FIXME implement remaining types and add unreachable!() to the fallback branch
             _ => self.placeholder_for_type(tcx, type_dbg, ty),
@@ -152,7 +152,7 @@ impl DebugContext {
         components: &'tcx [Ty<'tcx>],
     ) -> UnitEntryId {
         let components = components
-            .into_iter()
+            .iter()
             .map(|&ty| (ty, self.debug_type(tcx, type_dbg, ty)))
             .collect::<Vec<_>>();