Add miscellaneous Clippy 'corrections' (Shopify/zjit#92)

* Remove redundant  statements

* Remove .clone() since A64 implements Copy

* Remove .clone() since InsnId implements Copy

.

* Dereference since *const rb_call_data implements Copy

* Remove unnecessary return statement

* Remove unnecessary braces

* Use .is_empty() over length checks

* Remove unnecessary conversion handling

Since i32 can always fit into i64 (the inner type in Opnd::Imm), the conversion is infallibile.

* Use slice notation in lieu of Vec

https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg

* Simplify match statement

Author: aidenfoxivey

zjit/src/asm/x86_64/mod.rs

@@ -297,13 +297,11 @@ pub fn mem_opnd(num_bits: u8, base_reg: X86Opnd, disp: i32) -> X86Opnd
 /// Memory operand with SIB (Scale Index Base) indexing
 pub fn mem_opnd_sib(num_bits: u8, base_opnd: X86Opnd, index_opnd: X86Opnd, scale: i32, disp: i32) -> X86Opnd {
     if let (X86Opnd::Reg(base_reg), X86Opnd::Reg(index_reg)) = (base_opnd, index_opnd) {
-        let scale_exp: u8;
-
-        match scale {
-            8 => { scale_exp = 3; },
-            4 => { scale_exp = 2; },
-            2 => { scale_exp = 1; },
-            1 => { scale_exp = 0; },
+        let scale_exp: u8 = match scale {
+            8 => 3,
+            4 => 2,
+            2 => 1,
+            1 => 0,
             _ => unreachable!()
         };
 

zjit/src/backend/arm64/mod.rs

@@ -1276,7 +1276,7 @@ impl Assembler
 
         // Error if we couldn't write out everything
         if cb.has_dropped_bytes() {
-            return Err(EmitError::OutOfMemory)
+            Err(EmitError::OutOfMemory)
         } else {
             // No bytes dropped, so the pos markers point to valid code
             for (insn_idx, pos) in pos_markers {
@@ -1287,7 +1287,7 @@ impl Assembler
                 }
             }
 
-            return Ok(gc_offsets)
+            Ok(gc_offsets)
         }
     }
 

zjit/src/backend/lir.rs

@@ -160,7 +160,7 @@ impl Opnd
 
     /// Maps the indices from a previous list of instructions to a new list of
     /// instructions.
-    pub fn map_index(self, indices: &Vec<usize>) -> Opnd {
+    pub fn map_index(self, indices: &[usize]) -> Opnd {
         match self {
             Opnd::VReg { idx, num_bits } => {
                 Opnd::VReg { idx: indices[idx], num_bits }
@@ -249,7 +249,7 @@ impl From<i64> for Opnd {
 
 impl From<i32> for Opnd {
     fn from(value: i32) -> Self {
-        Opnd::Imm(value.try_into().unwrap())
+        Opnd::Imm(value.into())
     }
 }
 
@@ -1027,7 +1027,7 @@ impl RegisterPool {
         assert_eq!(self.pool[reg_idx], None, "register already allocated");
         self.pool[reg_idx] = Some(vreg_idx);
         self.live_regs += 1;
-        return *reg;
+        *reg
     }
 
     // Mutate the pool to indicate that the given register is being returned
@@ -1395,15 +1395,15 @@ impl Assembler
             .filter(|&(reg, opnd)| Opnd::Reg(reg) != opnd).collect();
 
         let mut new_moves = vec![];
-        while old_moves.len() > 0 {
+        while !old_moves.is_empty() {
             // Keep taking safe moves
             while let Some(index) = find_safe_move(&old_moves) {
                 new_moves.push(old_moves.remove(index));
             }
 
             // No safe move. Load the source of one move into SCRATCH_REG, and
             // then load SCRATCH_REG into the destination when it's safe.
-            if old_moves.len() > 0 {
+            if !old_moves.is_empty() {
                 // Make sure it's safe to use SCRATCH_REG
                 assert!(old_moves.iter().all(|&(_, opnd)| opnd != Opnd::Reg(Assembler::SCRATCH_REG)));
 
@@ -1499,7 +1499,7 @@ impl Assembler
                     }
                     // On x86_64, maintain 16-byte stack alignment
                     if cfg!(target_arch = "x86_64") && saved_regs.len() % 2 == 1 {
-                        asm.cpush(Opnd::Reg(saved_regs.last().unwrap().0.clone()));
+                        asm.cpush(Opnd::Reg(saved_regs.last().unwrap().0));
                     }
                 }
                 _ => {},

zjit/src/cruby.rs

@@ -394,7 +394,7 @@ impl VALUE {
 
     /// Return true for a dynamic Ruby symbol (RB_DYNAMIC_SYM_P)
     fn dynamic_sym_p(self) -> bool {
-        return if self.special_const_p() {
+        if self.special_const_p() {
             false
         } else {
             self.builtin_type() == RUBY_T_SYMBOL
@@ -426,7 +426,7 @@ impl VALUE {
         let VALUE(cval) = self;
         let rbasic_ptr = cval as *const RBasic;
         let flags_bits: usize = unsafe { (*rbasic_ptr).flags }.as_usize();
-        return flags_bits;
+        flags_bits
     }
 
     pub fn class_of(self) -> VALUE {

zjit/src/hir.rs

@@ -736,22 +736,22 @@ impl Function {
             SendWithoutBlock { self_val, call_info, cd, args, state } => SendWithoutBlock {
                 self_val: find!(*self_val),
                 call_info: call_info.clone(),
-                cd: cd.clone(),
+                cd: *cd,
                 args: args.iter().map(|arg| find!(*arg)).collect(),
                 state: *state,
             },
             SendWithoutBlockDirect { self_val, call_info, cd, iseq, args, state } => SendWithoutBlockDirect {
                 self_val: find!(*self_val),
                 call_info: call_info.clone(),
-                cd: cd.clone(),
+                cd: *cd,
                 iseq: *iseq,
                 args: args.iter().map(|arg| find!(*arg)).collect(),
                 state: *state,
             },
             Send { self_val, call_info, cd, blockiseq, args, state } => Send {
                 self_val: find!(*self_val),
                 call_info: call_info.clone(),
-                cd: cd.clone(),
+                cd: *cd,
                 blockiseq: *blockiseq,
                 args: args.iter().map(|arg| find!(*arg)).collect(),
                 state: *state,
@@ -1303,7 +1303,7 @@ impl FrameState {
     }
 
     fn as_args(&self) -> Vec<InsnId> {
-        self.locals.iter().chain(self.stack.iter()).map(|op| op.clone()).collect()
+        self.locals.iter().chain(self.stack.iter()).map(|op| *op).collect()
     }
 }
 

zjit/src/options.rs

@@ -111,7 +111,7 @@ fn parse_option(options: &mut Options, str_ptr: *const std::os::raw::c_char) ->
     }
 
     // Option successfully parsed
-    return Some(());
+    Some(())
 }
 
 /// Macro to print a message only when --zjit-debug is given

zjit/src/virtualmem.rs

@@ -5,7 +5,7 @@
 
 use std::ptr::NonNull;
 
-use crate::{stats::zjit_alloc_size};
+use crate::stats::zjit_alloc_size;
 
 #[cfg(not(test))]
 pub type VirtualMem = VirtualMemory<sys::SystemAllocator>;
@@ -78,7 +78,7 @@ impl CodePtr {
     /// been any writes to it through the [VirtualMemory] yet.
     pub fn raw_ptr(self, base: &impl CodePtrBase) -> *const u8 {
         let CodePtr(offset) = self;
-        return base.base_ptr().as_ptr().wrapping_add(offset as usize)
+        base.base_ptr().as_ptr().wrapping_add(offset as usize)
     }
 
     /// Get the address of the code pointer.