Fix clippy warnings in rustc_codegen_nvvm (part 1)

- Fix collapsible-if warnings using && syntax
- Fix uninlined format args warnings
- Fix unnecessary-mut-passed warning

Author: LegNeato

crates/rustc_codegen_nvvm/src/abi.rs

@@ -43,14 +43,14 @@ pub(crate) fn readjust_fn_abi<'tcx>(
             arg.mode = PassMode::Ignore;
         }
 
-        if let TyKind::Ref(_, ty, _) = arg.layout.ty.kind() {
-            if matches!(ty.kind(), TyKind::Slice(_)) {
-                let mut ptr_attrs = ArgAttributes::new();
-                if let PassMode::Indirect { attrs, .. } = arg.mode {
-                    ptr_attrs.regular = attrs.regular;
-                }
-                arg.mode = PassMode::Pair(ptr_attrs, ArgAttributes::new());
+        if let TyKind::Ref(_, ty, _) = arg.layout.ty.kind()
+            && matches!(ty.kind(), TyKind::Slice(_))
+        {
+            let mut ptr_attrs = ArgAttributes::new();
+            if let PassMode::Indirect { attrs, .. } = arg.mode {
+                ptr_attrs.regular = attrs.regular;
             }
+            arg.mode = PassMode::Pair(ptr_attrs, ArgAttributes::new());
         }
 
         if arg.layout.ty.is_array() && !matches!(arg.mode, PassMode::Direct { .. }) {
@@ -491,11 +491,12 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
             // If the value is a boolean, the range is 0..2 and that ultimately
             // become 0..0 when the type becomes i1, which would be rejected
             // by the LLVM verifier.
-            if let Primitive::Int(..) = scalar.primitive() {
-                if !scalar.is_bool() && !scalar.is_always_valid(bx) {
-                    trace!("apply_attrs_callsite -> range_metadata");
-                    bx.range_metadata(callsite, scalar.valid_range(bx));
-                }
+            if let Primitive::Int(..) = scalar.primitive()
+                && !scalar.is_bool()
+                && !scalar.is_always_valid(bx)
+            {
+                trace!("apply_attrs_callsite -> range_metadata");
+                bx.range_metadata(callsite, scalar.valid_range(bx));
             }
         }
         for arg in self.args.iter() {
@@ -549,11 +550,11 @@ impl<'tcx> AbiBuilderMethods for Builder<'_, '_, 'tcx> {
             // destructure so rustc doesnt complain in the call to transmute_llval
             let Self { cx, llbuilder } = self;
             let map = cx.remapped_integer_args.borrow();
-            if let Some((_, key)) = map.get(&llfnty) {
-                if let Some((_, new_ty)) = key.iter().find(|t| t.0 == index) {
-                    trace!("Casting irregular param {:?} to {:?}", val, new_ty);
-                    return transmute_llval(llbuilder, cx, val, new_ty);
-                }
+            if let Some((_, key)) = map.get(&llfnty)
+                && let Some((_, new_ty)) = key.iter().find(|t| t.0 == index)
+            {
+                trace!("Casting irregular param {:?} to {:?}", val, new_ty);
+                return transmute_llval(llbuilder, cx, val, new_ty);
             }
             val
         };

crates/rustc_codegen_nvvm/src/back.rs

@@ -29,7 +29,7 @@ use crate::{LlvmMod, NvvmCodegenBackend, builder::Builder, context::CodegenCx, l
 
 pub fn llvm_err(handle: DiagCtxtHandle, msg: &str) -> FatalError {
     match llvm::last_error() {
-        Some(err) => handle.fatal(format!("{}: {}", msg, err)),
+        Some(err) => handle.fatal(format!("{msg}: {err}")),
         None => handle.fatal(msg.to_string()),
     }
 }
@@ -121,7 +121,7 @@ pub fn target_machine_factory(
                 false,
             )
         };
-        tm.ok_or_else(|| format!("Could not create LLVM TargetMachine for triple: {}", triple))
+        tm.ok_or_else(|| format!("Could not create LLVM TargetMachine for triple: {triple}"))
     })
 }
 
@@ -146,7 +146,7 @@ pub extern "C" fn demangle_callback(
         Err(_) => return 0,
     };
 
-    if write!(cursor, "{:#}", demangled).is_err() {
+    if write!(cursor, "{demangled:#}").is_err() {
         // Possible only if provided buffer is not big enough
         return 0;
     }
@@ -199,7 +199,7 @@ pub(crate) unsafe fn codegen(
         };
 
         result.into_result().map_err(|()| {
-            let msg = format!("failed to write NVVM IR to {}", out);
+            let msg = format!("failed to write NVVM IR to {out}");
             llvm_err(dcx, &msg)
         })?;
     }
@@ -288,7 +288,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
             // a main function for gpu kernels really makes no sense but
             // codegen it anyways.
             // sanitize attrs are not allowed in nvvm so do nothing further.
-            maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&mut cx, cgu);
+            maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&cx, cgu);
 
             // Run replace-all-uses-with for statics that need it
             for &(old_g, new_g) in cx.statics_to_rauw.borrow().iter() {
@@ -390,7 +390,7 @@ pub(crate) unsafe fn optimize(
 
             for pass in &config.passes {
                 if !addpass(pass) {
-                    diag_handler.warn(format!("unknown pass `{}`, ignoring", pass));
+                    diag_handler.warn(format!("unknown pass `{pass}`, ignoring"));
                 }
             }
 

crates/rustc_codegen_nvvm/src/builder.rs

@@ -522,10 +522,10 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                         bx.nonnull_metadata(load);
                     }
 
-                    if let Some(pointee) = layout.pointee_info_at(bx, offset) {
-                        if pointee.safe.is_some() {
-                            bx.align_metadata(load, pointee.align);
-                        }
+                    if let Some(pointee) = layout.pointee_info_at(bx, offset)
+                        && pointee.safe.is_some()
+                    {
+                        bx.align_metadata(load, pointee.align);
                     }
                 }
                 abi::Primitive::Float(_) => {}
@@ -539,14 +539,12 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
             let mut const_llval = None;
             let llty = place.layout.llvm_type(self);
             unsafe {
-                if let Some(global) = llvm::LLVMIsAGlobalVariable(place.val.llval) {
-                    if llvm::LLVMIsGlobalConstant(global) == llvm::True {
-                        if let Some(init) = llvm::LLVMGetInitializer(global) {
-                            if self.val_ty(init) == llty {
-                                const_llval = Some(init);
-                            }
-                        }
-                    }
+                if let Some(global) = llvm::LLVMIsAGlobalVariable(place.val.llval)
+                    && llvm::LLVMIsGlobalConstant(global) == llvm::True
+                    && let Some(init) = llvm::LLVMGetInitializer(global)
+                    && self.val_ty(init) == llty
+                {
+                    const_llval = Some(init);
                 }
             }
 
@@ -1212,9 +1210,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
     ) -> Cow<'b, [&'ll Value]> {
         assert!(
             self.cx.type_kind(fn_ty) == TypeKind::Function,
-            "builder::{} not passed a function, but {:?}",
-            typ,
-            fn_ty
+            "builder::{typ} not passed a function, but {fn_ty:?}"
         );
 
         let param_tys = self.cx.func_params_types(fn_ty);

crates/rustc_codegen_nvvm/src/consts.rs

@@ -186,7 +186,7 @@ fn check_and_apply_linkage<'ll, 'tcx>(
             _ => cx
                 .sess()
                 .dcx()
-                .fatal(format!("Unsupported linkage kind: {:?}", linkage)),
+                .fatal(format!("Unsupported linkage kind: {linkage:?}")),
         }
 
         // If this is a static with a linkage specified, then we need to handle
@@ -276,8 +276,7 @@ impl<'ll> CodegenCx<'ll, '_> {
         assert!(
             !defined_in_current_codegen_unit,
             "consts::get_static() should always hit the cache for \
-                 statics defined in the same CGU, but did not for `{:?}`",
-            def_id
+                 statics defined in the same CGU, but did not for `{def_id:?}`"
         );
 
         let ty = instance.ty(self.tcx, self.typing_env());
@@ -286,10 +285,10 @@ impl<'ll> CodegenCx<'ll, '_> {
 
         let g = if def_id.is_local() && !self.tcx.is_foreign_item(def_id) {
             let llty = self.layout_of(ty).llvm_type(self);
-            if let Some(g) = self.get_declared_value(sym) {
-                if self.val_ty(g) != self.type_ptr_to(llty) {
-                    span_bug!(self.tcx.def_span(def_id), "Conflicting types for static");
-                }
+            if let Some(g) = self.get_declared_value(sym)
+                && self.val_ty(g) != self.type_ptr_to(llty)
+            {
+                span_bug!(self.tcx.def_span(def_id), "Conflicting types for static");
             }
 
             let addrspace = self.static_addrspace(instance);

crates/rustc_codegen_nvvm/src/context.rs

@@ -184,7 +184,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
 
     // im lazy i know
     pub(crate) fn unsupported(&self, thing: &str) -> ! {
-        self.fatal(format!("{} is unsupported", thing))
+        self.fatal(format!("{thing} is unsupported"))
     }
 
     pub(crate) fn create_used_variable_impl(&self, name: &'static CStr, values: &[&'ll Value]) {
@@ -282,8 +282,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 let layout = self.layout_of(ty);
                 if layout.size.bytes() > CONSTANT_MEMORY_SIZE_LIMIT_BYTES {
                     self.tcx.sess.dcx().warn(format!(
-                    "static `{}` exceeds the constant memory limit; placing in global memory (performance may be reduced)",
-                    instance
+                    "static `{instance}` exceeds the constant memory limit; placing in global memory (performance may be reduced)"
                 ));
                     // Place instance in global memory if it is too big for constant memory.
                     AddressSpace(1)