Fix many clippy warnings

23 files changed, 88 insertions, 109 deletions

diff --git a/src/abi/comments.rs b/src/abi/comments.rs
index 7bb00c8d46a..01073d26e83 100644
--- a/src/abi/comments.rs
+++ b/src/abi/comments.rs
@@ -11,9 +11,9 @@ use crate::abi::pass_mode::*;
 use crate::prelude::*;
 
 pub(super) fn add_args_header_comment(fx: &mut FunctionCx<'_, '_, impl Module>) {
-    fx.add_global_comment(format!(
-        "kind  loc.idx   param    pass mode                            ty"
-    ));
+    fx.add_global_comment(
+        "kind  loc.idx   param    pass mode                            ty".to_string(),
+    );
 }
 
 pub(super) fn add_arg_comment<'tcx>(
@@ -56,9 +56,9 @@ pub(super) fn add_arg_comment<'tcx>(
 
 pub(super) fn add_locals_header_comment(fx: &mut FunctionCx<'_, '_, impl Module>) {
     fx.add_global_comment(String::new());
-    fx.add_global_comment(format!(
-        "kind  local ty                              size align (abi,pref)"
-    ));
+    fx.add_global_comment(
+        "kind  local ty                              size align (abi,pref)".to_string(),
+    );
 }
 
 pub(super) fn add_local_place_comments<'tcx>(
diff --git a/src/abi/mod.rs b/src/abi/mod.rs
index 80169122843..1fa36b944f7 100644
--- a/src/abi/mod.rs
+++ b/src/abi/mod.rs
@@ -300,7 +300,7 @@ impl<'tcx, M: Module> FunctionCx<'_, 'tcx, M> {
         return_ty: Ty<'tcx>,
     ) -> CValue<'tcx> {
         let (input_tys, args): (Vec<_>, Vec<_>) = args
-            .into_iter()
+            .iter()
             .map(|arg| {
                 (
                     self.clif_type(arg.layout().ty).unwrap(),
@@ -421,34 +421,31 @@ pub(crate) fn codegen_fn_prelude<'tcx>(
 
         // While this is normally an optimization to prevent an unnecessary copy when an argument is
         // not mutated by the current function, this is necessary to support unsized arguments.
-        match arg_kind {
-            ArgKind::Normal(Some(val)) => {
-                if let Some((addr, meta)) = val.try_to_ptr() {
-                    let local_decl = &fx.mir.local_decls[local];
-                    //                       v this ! is important
-                    let internally_mutable = !val.layout().ty.is_freeze(
-                        fx.tcx.at(local_decl.source_info.span),
-                        ParamEnv::reveal_all(),
-                    );
-                    if local_decl.mutability == mir::Mutability::Not && !internally_mutable {
-                        // We wont mutate this argument, so it is fine to borrow the backing storage
-                        // of this argument, to prevent a copy.
-
-                        let place = if let Some(meta) = meta {
-                            CPlace::for_ptr_with_extra(addr, meta, val.layout())
-                        } else {
-                            CPlace::for_ptr(addr, val.layout())
-                        };
-
-                        #[cfg(debug_assertions)]
-                        self::comments::add_local_place_comments(fx, place, local);
-
-                        assert_eq!(fx.local_map.push(place), local);
-                        continue;
-                    }
+        if let ArgKind::Normal(Some(val)) = arg_kind {
+            if let Some((addr, meta)) = val.try_to_ptr() {
+                let local_decl = &fx.mir.local_decls[local];
+                //                       v this ! is important
+                let internally_mutable = !val.layout().ty.is_freeze(
+                    fx.tcx.at(local_decl.source_info.span),
+                    ParamEnv::reveal_all(),
+                );
+                if local_decl.mutability == mir::Mutability::Not && !internally_mutable {
+                    // We wont mutate this argument, so it is fine to borrow the backing storage
+                    // of this argument, to prevent a copy.
+
+                    let place = if let Some(meta) = meta {
+                        CPlace::for_ptr_with_extra(addr, meta, val.layout())
+                    } else {
+                        CPlace::for_ptr(addr, val.layout())
+                    };
+
+                    #[cfg(debug_assertions)]
+                    self::comments::add_local_place_comments(fx, place, local);
+
+                    assert_eq!(fx.local_map.push(place), local);
+                    continue;
                 }
             }
-            _ => {}
         }
 
         let place = make_local_place(fx, local, layout, is_ssa);
@@ -568,7 +565,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
         }
         args
     } else {
-        args.into_iter()
+        args.iter()
             .map(|arg| trans_operand(fx, arg))
             .collect::<Vec<_>>()
     };
diff --git a/src/allocator.rs b/src/allocator.rs
index 0735ad6f832..6c5916550ff 100644
--- a/src/allocator.rs
+++ b/src/allocator.rs
@@ -123,7 +123,7 @@ fn codegen_inner(
         .unwrap();
 
     let mut ctx = Context::new();
-    ctx.func = Function::with_name_signature(ExternalName::user(0, 0), sig.clone());
+    ctx.func = Function::with_name_signature(ExternalName::user(0, 0), sig);
     {
         let mut func_ctx = FunctionBuilderContext::new();
         let mut bcx = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
@@ -131,7 +131,7 @@ fn codegen_inner(
         let block = bcx.create_block();
         bcx.switch_to_block(block);
         let args = (&[usize_ty, usize_ty])
-            .into_iter()
+            .iter()
             .map(|&ty| bcx.append_block_param(block, ty))
             .collect::<Vec<Value>>();
 
diff --git a/src/archive.rs b/src/archive.rs
index 6382f8df344..9a970efbcfd 100644
--- a/src/archive.rs
+++ b/src/archive.rs
@@ -132,7 +132,7 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
             }
 
             // ok, don't skip this
-            return false;
+            false
         })
     }
 
diff --git a/src/atomic_shim.rs b/src/atomic_shim.rs
index 92281fdacc9..2f0157c257b 100644
--- a/src/atomic_shim.rs
+++ b/src/atomic_shim.rs
@@ -7,7 +7,7 @@ use crate::prelude::*;
 
 #[cfg(all(feature = "jit", unix))]
 #[no_mangle]
-pub static mut __cg_clif_global_atomic_mutex: libc::pthread_mutex_t =
+static mut __cg_clif_global_atomic_mutex: libc::pthread_mutex_t =
     libc::PTHREAD_MUTEX_INITIALIZER;
 
 pub(crate) fn init_global_lock(
diff --git a/src/backend.rs b/src/backend.rs
index 8b900fd0dd0..aac37b376dc 100644
--- a/src/backend.rs
+++ b/src/backend.rs
@@ -73,7 +73,7 @@ impl WriteDebugInfo for ObjectProduct {
         // FIXME use SHT_X86_64_UNWIND for .eh_frame
         let section_id = self.object.add_section(
             segment,
-            name.clone(),
+            name,
             if id == SectionId::EhFrame {
                 SectionKind::ReadOnlyData
             } else {
@@ -201,6 +201,5 @@ pub(crate) fn make_module(sess: &Session, name: String) -> ObjectModule {
     if std::env::var("CG_CLIF_FUNCTION_SECTIONS").is_ok() {
         builder.per_function_section(true);
     }
-    let module = ObjectModule::new(builder);
-    module
+    ObjectModule::new(builder)
 }
diff --git a/src/base.rs b/src/base.rs
index fa9b8853d39..3e455dbc0e2 100644
--- a/src/base.rs
+++ b/src/base.rs
@@ -753,7 +753,7 @@ fn trans_stmt<'tcx>(
                 }
                 Rvalue::Aggregate(kind, operands) => match **kind {
                     AggregateKind::Array(_ty) => {
-                        for (i, operand) in operands.into_iter().enumerate() {
+                        for (i, operand) in operands.iter().enumerate() {
                             let operand = trans_operand(fx, operand);
                             let index = fx.bcx.ins().iconst(fx.pointer_type, i as i64);
                             let to = lval.place_index(fx, index);
@@ -938,7 +938,7 @@ pub(crate) fn trans_place<'tcx>(
                         let ptr = cplace.to_ptr();
                         cplace = CPlace::for_ptr(
                             ptr.offset_i64(fx, elem_layout.size.bytes() as i64 * (from as i64)),
-                            fx.layout_of(fx.tcx.mk_array(elem_ty, u64::from(to) - u64::from(from))),
+                            fx.layout_of(fx.tcx.mk_array(elem_ty, to - from)),
                         );
                     }
                     ty::Slice(elem_ty) => {
diff --git a/src/cast.rs b/src/cast.rs
index 122a36b5bf7..57204de1135 100644
--- a/src/cast.rs
+++ b/src/cast.rs
@@ -181,12 +181,10 @@ pub(crate) fn clif_int_or_float_cast(
                 fx.bcx.ins().select(has_overflow, max_val, val)
             };
             fx.bcx.ins().ireduce(to_ty, val)
+        } else if to_signed {
+            fx.bcx.ins().fcvt_to_sint_sat(to_ty, from)
         } else {
-            if to_signed {
-                fx.bcx.ins().fcvt_to_sint_sat(to_ty, from)
-            } else {
-                fx.bcx.ins().fcvt_to_uint_sat(to_ty, from)
-            }
+            fx.bcx.ins().fcvt_to_uint_sat(to_ty, from)
         }
     } else if from_ty.is_float() && to_ty.is_float() {
         // float -> float
diff --git a/src/codegen_i128.rs b/src/codegen_i128.rs
index e998403dea6..d6a38bdafc9 100644
--- a/src/codegen_i128.rs
+++ b/src/codegen_i128.rs
@@ -21,9 +21,9 @@ pub(crate) fn maybe_codegen<'tcx>(
     match bin_op {
         BinOp::BitAnd | BinOp::BitOr | BinOp::BitXor => {
             assert!(!checked);
-            return None;
+            None
         }
-        BinOp::Add | BinOp::Sub if !checked => return None,
+        BinOp::Add | BinOp::Sub if !checked => None,
         BinOp::Add => {
             let out_ty = fx.tcx.mk_tup([lhs.layout().ty, fx.tcx.types.bool].iter());
             return Some(if is_signed {
@@ -57,7 +57,7 @@ pub(crate) fn maybe_codegen<'tcx>(
                 };
                 fx.easy_call("__multi3", &[lhs, rhs], val_ty)
             };
-            return Some(res);
+            Some(res)
         }
         BinOp::Div => {
             assert!(!checked);
@@ -77,7 +77,7 @@ pub(crate) fn maybe_codegen<'tcx>(
         }
         BinOp::Lt | BinOp::Le | BinOp::Eq | BinOp::Ge | BinOp::Gt | BinOp::Ne => {
             assert!(!checked);
-            return None;
+            None
         }
         BinOp::Shl | BinOp::Shr => {
             let is_overflow = if checked {
diff --git a/src/constant.rs b/src/constant.rs
index 1b514958a48..bdf9ccba62a 100644
--- a/src/constant.rs
+++ b/src/constant.rs
@@ -188,7 +188,7 @@ pub(crate) fn trans_const_value<'tcx>(
             match x {
                 Scalar::Raw { data, size } => {
                     assert_eq!(u64::from(size), layout.size.bytes());
-                    return CValue::const_val(fx, layout, data);
+                    CValue::const_val(fx, layout, data)
                 }
                 Scalar::Ptr(ptr) => {
                     let alloc_kind = fx.tcx.get_global_alloc(ptr.alloc_id);
@@ -232,7 +232,7 @@ pub(crate) fn trans_const_value<'tcx>(
                     } else {
                         base_addr
                     };
-                    return CValue::by_val(val, layout);
+                    CValue::by_val(val, layout)
                 }
             }
         }
@@ -293,14 +293,12 @@ fn data_id_for_static(
     let rlinkage = tcx.codegen_fn_attrs(def_id).linkage;
     let linkage = if definition {
         crate::linkage::get_static_linkage(tcx, def_id)
+    } else if rlinkage == Some(rustc_middle::mir::mono::Linkage::ExternalWeak)
+        || rlinkage == Some(rustc_middle::mir::mono::Linkage::WeakAny)
+    {
+        Linkage::Preemptible
     } else {
-        if rlinkage == Some(rustc_middle::mir::mono::Linkage::ExternalWeak)
-            || rlinkage == Some(rustc_middle::mir::mono::Linkage::WeakAny)
-        {
-            Linkage::Preemptible
-        } else {
-            Linkage::Import
-        }
+        Linkage::Import
     };
 
     let instance = Instance::mono(tcx, def_id).polymorphize(tcx);
diff --git a/src/debuginfo/emit.rs b/src/debuginfo/emit.rs
index cf8fee2b1d1..f6f795e4561 100644
--- a/src/debuginfo/emit.rs
+++ b/src/debuginfo/emit.rs
@@ -195,9 +195,7 @@ impl Writer for WriterRelocate {
                     });
                     self.write_udata(0, size)
                 }
-                _ => {
-                    return Err(gimli::write::Error::UnsupportedPointerEncoding(eh_pe));
-                }
+                _ => Err(gimli::write::Error::UnsupportedPointerEncoding(eh_pe)),
             },
         }
     }
diff --git a/src/debuginfo/line_info.rs b/src/debuginfo/line_info.rs
index 4de84855328..d226755d85d 100644
--- a/src/debuginfo/line_info.rs
+++ b/src/debuginfo/line_info.rs
@@ -49,7 +49,7 @@ fn osstr_as_utf8_bytes(path: &OsStr) -> &[u8] {
 
 pub(crate) const MD5_LEN: usize = 16;
 
-pub fn make_file_info(hash: SourceFileHash) -> Option<FileInfo> {
+pub(crate) fn make_file_info(hash: SourceFileHash) -> Option<FileInfo> {
     if hash.kind == SourceFileHashAlgorithm::Md5 {
         let mut buf = [0u8; MD5_LEN];
         buf.copy_from_slice(hash.hash_bytes());
@@ -190,7 +190,7 @@ impl<'tcx> DebugContext<'tcx> {
             if current_file_changed {
                 let file_id = line_program_add_file(line_program, line_strings, &file);
                 line_program.row().file = file_id;
-                last_file = Some(file.clone());
+                last_file = Some(file);
             }
 
             line_program.row().line = line;
diff --git a/src/driver/jit.rs b/src/driver/jit.rs
index b5bab3d9e1e..3f47df7d844 100644
--- a/src/driver/jit.rs
+++ b/src/driver/jit.rs
@@ -94,7 +94,7 @@ pub(super) fn run_jit(tcx: TyCtxt<'_>) -> ! {
 
     let args = ::std::env::var("CG_CLIF_JIT_ARGS").unwrap_or_else(|_| String::new());
     let args = std::iter::once(&*tcx.crate_name(LOCAL_CRATE).as_str().to_string())
-        .chain(args.split(" "))
+        .chain(args.split(' '))
         .map(|arg| CString::new(arg).unwrap())
         .collect::<Vec<_>>();
     let mut argv = args.iter().map(|arg| arg.as_ptr()).collect::<Vec<_>>();
@@ -151,7 +151,7 @@ fn load_imported_symbols_for_jit(tcx: TyCtxt<'_>) -> Vec<(String, *const u8)> {
             }
             let dlsym_name = if cfg!(target_os = "macos") {
                 // On macOS `dlsym` expects the name without leading `_`.
-                assert!(name.starts_with("_"), "{:?}", name);
+                assert!(name.starts_with('_'), "{:?}", name);
                 &name[1..]
             } else {
                 &name
diff --git a/src/intrinsics/llvm.rs b/src/intrinsics/llvm.rs
index 18d86f0c5f9..171445f2d71 100644
--- a/src/intrinsics/llvm.rs
+++ b/src/intrinsics/llvm.rs
@@ -53,7 +53,7 @@ pub(crate) fn codegen_llvm_intrinsic_call<'tcx>(
         };
         llvm.x86.sse2.cmp.ps | llvm.x86.sse2.cmp.pd, (c x, c y, o kind) {
             let kind_const = crate::constant::mir_operand_get_const_val(fx, kind).expect("llvm.x86.sse2.cmp.* kind not const");
-            let flt_cc = match kind_const.val.try_to_bits(Size::from_bytes(1)).expect(&format!("kind not scalar: {:?}", kind_const)) {
+            let flt_cc = match kind_const.val.try_to_bits(Size::from_bytes(1)).unwrap_or_else(|| panic!("kind not scalar: {:?}", kind_const)) {
                 0 => FloatCC::Equal,
                 1 => FloatCC::LessThan,
                 2 => FloatCC::LessThanOrEqual,
@@ -84,7 +84,7 @@ pub(crate) fn codegen_llvm_intrinsic_call<'tcx>(
         llvm.x86.sse2.psrli.d, (c a, o imm8) {
             let imm8 = crate::constant::mir_operand_get_const_val(fx, imm8).expect("llvm.x86.sse2.psrli.d imm8 not const");
             simd_for_each_lane(fx, a, ret, |fx, _lane_layout, res_lane_layout, lane| {
-                let res_lane = match imm8.val.try_to_bits(Size::from_bytes(4)).expect(&format!("imm8 not scalar: {:?}", imm8)) {
+                let res_lane = match imm8.val.try_to_bits(Size::from_bytes(4)).unwrap_or_else(|| panic!("imm8 not scalar: {:?}", imm8)) {
                     imm8 if imm8 < 32 => fx.bcx.ins().ushr_imm(lane, i64::from(imm8 as u8)),
                     _ => fx.bcx.ins().iconst(types::I32, 0),
                 };
@@ -94,7 +94,7 @@ pub(crate) fn codegen_llvm_intrinsic_call<'tcx>(
         llvm.x86.sse2.pslli.d, (c a, o imm8) {
             let imm8 = crate::constant::mir_operand_get_const_val(fx, imm8).expect("llvm.x86.sse2.psrli.d imm8 not const");
             simd_for_each_lane(fx, a, ret, |fx, _lane_layout, res_lane_layout, lane| {
-                let res_lane = match imm8.val.try_to_bits(Size::from_bytes(4)).expect(&format!("imm8 not scalar: {:?}", imm8)) {
+                let res_lane = match imm8.val.try_to_bits(Size::from_bytes(4)).unwrap_or_else(|| panic!("imm8 not scalar: {:?}", imm8)) {
                     imm8 if imm8 < 32 => fx.bcx.ins().ishl_imm(lane, i64::from(imm8 as u8)),
                     _ => fx.bcx.ins().iconst(types::I32, 0),
                 };
diff --git a/src/intrinsics/simd.rs b/src/intrinsics/simd.rs
index b4269f4fafa..2e31c4669e2 100644
--- a/src/intrinsics/simd.rs
+++ b/src/intrinsics/simd.rs
@@ -127,7 +127,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                 );
             };
 
-            let idx = idx_const.val.try_to_bits(Size::from_bytes(4 /* u32*/)).expect(&format!("kind not scalar: {:?}", idx_const));
+            let idx = idx_const.val.try_to_bits(Size::from_bytes(4 /* u32*/)).unwrap_or_else(|| panic!("kind not scalar: {:?}", idx_const));
             let (_lane_type, lane_count) = lane_type_and_count(fx.tcx, base.layout());
             if idx >= lane_count.into() {
                 fx.tcx.sess.span_fatal(fx.mir.span, &format!("[simd_insert] idx {} >= lane_count {}", idx, lane_count));
@@ -149,7 +149,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                 );
             };
 
-            let idx = idx_const.val.try_to_bits(Size::from_bytes(4 /* u32*/)).expect(&format!("kind not scalar: {:?}", idx_const));
+            let idx = idx_const.val.try_to_bits(Size::from_bytes(4 /* u32*/)).unwrap_or_else(|| panic!("kind not scalar: {:?}", idx_const));
             let (_lane_type, lane_count) = lane_type_and_count(fx.tcx, v.layout());
             if idx >= lane_count.into() {
                 fx.tcx.sess.span_fatal(fx.mir.span, &format!("[simd_extract] idx {} >= lane_count {}", idx, lane_count));
diff --git a/src/lib.rs b/src/lib.rs
index fd00a2e00a6..7daff2a24b9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,6 +9,7 @@
 )]
 #![warn(rust_2018_idioms)]
 #![warn(unused_lifetimes)]
+#![warn(unreachable_pub)]
 
 #[cfg(feature = "jit")]
 extern crate libc;
diff --git a/src/linkage.rs b/src/linkage.rs
index fe5d1d64443..dc1e2107ce7 100644
--- a/src/linkage.rs
+++ b/src/linkage.rs
@@ -25,11 +25,9 @@ pub(crate) fn get_static_linkage(tcx: TyCtxt<'_>, def_id: DefId) -> Linkage {
             RLinkage::ExternalWeak | RLinkage::WeakAny => Linkage::Preemptible,
             _ => panic!("{:?}", linkage),
         }
+    } else if tcx.is_reachable_non_generic(def_id) {
+        Linkage::Export
     } else {
-        if tcx.is_reachable_non_generic(def_id) {
-            Linkage::Export
-        } else {
-            Linkage::Hidden
-        }
+        Linkage::Hidden
     }
 }
diff --git a/src/main_shim.rs b/src/main_shim.rs
index db34d89fe2b..10f515e38ea 100644
--- a/src/main_shim.rs
+++ b/src/main_shim.rs
@@ -76,7 +76,7 @@ pub(crate) fn maybe_create_entry_wrapper(
             .unwrap();
 
         let mut ctx = Context::new();
-        ctx.func = Function::with_name_signature(ExternalName::user(0, 0), cmain_sig.clone());
+        ctx.func = Function::with_name_signature(ExternalName::user(0, 0), cmain_sig);
         {
             let mut func_ctx = FunctionBuilderContext::new();
             let mut bcx = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
diff --git a/src/metadata.rs b/src/metadata.rs
index 04369bf89fd..cda2a187ff9 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -29,7 +29,7 @@ impl MetadataLoader for CraneliftMetadataLoader {
                         .expect("Rlib metadata file too big to load into memory."),
                 );
                 ::std::io::copy(&mut entry, &mut buf).map_err(|e| format!("{:?}", e))?;
-                let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
+                let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf);
                 return Ok(rustc_erase_owner!(buf.map_owner_box()));
             }
         }
@@ -47,7 +47,7 @@ impl MetadataLoader for CraneliftMetadataLoader {
             .data()
             .map_err(|e| format!("failed to read .rustc section: {:?}", e))?
             .to_owned();
-        let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
+        let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf);
         Ok(rustc_erase_owner!(buf.map_owner_box()))
     }
 }
diff --git a/src/optimize/stack2reg.rs b/src/optimize/stack2reg.rs
index f368d65f7f8..3c939d5a586 100644
--- a/src/optimize/stack2reg.rs
+++ b/src/optimize/stack2reg.rs
@@ -228,7 +228,8 @@ pub(super) fn optimize_function(
             match *potential_stores {
                 [] => {
                     #[cfg(debug_assertions)]
-                    clif_comments.add_comment(load, format!("[BUG?] Reading uninitialized memory"));
+                    clif_comments
+                        .add_comment(load, "[BUG?] Reading uninitialized memory".to_string());
                 }
                 [store]
                     if spatial_overlap(&opt_ctx.ctx.func, store, load) == SpatialOverlap::Full
diff --git a/src/pretty_clif.rs b/src/pretty_clif.rs
index 7f8ab953d71..ff878af7f5e 100644
--- a/src/pretty_clif.rs
+++ b/src/pretty_clif.rs
@@ -131,11 +131,11 @@ impl FuncWriter for &'_ CommentWriter {
             if !comment.is_empty() {
                 writeln!(w, "; {}", comment)?;
             } else {
-                writeln!(w, "")?;
+                writeln!(w)?;
             }
         }
         if !self.global_comments.is_empty() {
-            writeln!(w, "")?;
+            writeln!(w)?;
         }
 
         self.super_preamble(w, func, reg_info)
@@ -153,7 +153,7 @@ impl FuncWriter for &'_ CommentWriter {
         if let Some(comment) = self.entity_comments.get(&entity) {
             writeln!(w, " ; {}", comment.replace('\n', "\n; "))
         } else {
-            writeln!(w, "")
+            writeln!(w)
         }
     }
 
@@ -261,7 +261,7 @@ pub(crate) fn write_clif_file<'tcx>(
         writeln!(file, "set is_pic")?;
         writeln!(file, "set enable_simd")?;
         writeln!(file, "target {} haswell", target_triple)?;
-        writeln!(file, "")?;
+        writeln!(file)?;
         file.write_all(clif.as_bytes())?;
     };
     if let Err(err) = res {
diff --git a/src/value_and_place.rs b/src/value_and_place.rs
index 5d513cb3ea0..9a2470ba40d 100644
--- a/src/value_and_place.rs
+++ b/src/value_and_place.rs
@@ -27,10 +27,10 @@ fn codegen_field<'tcx>(
             return simple(fx);
         }
         match field_layout.ty.kind() {
-            ty::Slice(..) | ty::Str | ty::Foreign(..) => return simple(fx),
+            ty::Slice(..) | ty::Str | ty::Foreign(..) => simple(fx),
             ty::Adt(def, _) if def.repr.packed() => {
                 assert_eq!(layout.align.abi.bytes(), 1);
-                return simple(fx);
+                simple(fx)
             }
             _ => {
                 // We have to align the offset for DST's
@@ -237,15 +237,12 @@ impl<'tcx> CValue<'tcx> {
 
         let clif_ty = fx.clif_type(layout.ty).unwrap();
 
-        match layout.ty.kind() {
-            ty::Bool => {
-                assert!(
-                    const_val == 0 || const_val == 1,
-                    "Invalid bool 0x{:032X}",
-                    const_val
-                );
-            }
-            _ => {}
+        if let ty::Bool = layout.ty.kind() {
+            assert!(
+                const_val == 0 || const_val == 1,
+                "Invalid bool 0x{:032X}",
+                const_val
+            );
         }
 
         let val = match layout.ty.kind() {
diff --git a/src/vtable.rs b/src/vtable.rs
index bb3cf8b3f3a..238abc0d8bd 100644
--- a/src/vtable.rs
+++ b/src/vtable.rs
@@ -108,14 +108,14 @@ fn build_vtable<'tcx>(
         (&[]).iter()
     };
     let methods = methods.cloned().map(|opt_mth| {
-        opt_mth.map_or(None, |(def_id, substs)| {
-            Some(import_function(
+        opt_mth.map(|(def_id, substs)| {
+            import_function(
                 tcx,
                 &mut fx.cx.module,
                 Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs)
                     .unwrap()
                     .polymorphize(fx.tcx),
-            ))
+            )
         })
     });
     components.extend(methods);
@@ -137,15 +137,7 @@ fn build_vtable<'tcx>(
         }
     }
 
-    data_ctx.set_align(
-        fx.tcx
-            .data_layout
-            .pointer_align
-            .pref
-            .bytes()
-            .try_into()
-            .unwrap(),
-    );
+    data_ctx.set_align(fx.tcx.data_layout.pointer_align.pref.bytes());
 
     let data_id = fx
         .cx