clippy: Fix Clippy reports

Actually, let Clippy fix most of these itself. I only removed the unused
ErrorKind import from tests/misc.rs.

Signed-off-by: Quentin Monnet <qmo@qmon.net>

Author: qmonnet

src/disassembler.rs

@@ -196,7 +196,7 @@ pub struct HLInsn {
 /// ]);
 /// ```
 pub fn to_insn_vec(prog: &[u8]) -> Vec<HLInsn> {
-    if prog.len() % ebpf::INSN_SIZE != 0 {
+    if !prog.len().is_multiple_of(ebpf::INSN_SIZE) {
         panic!(
             "[Disassembler] Error: eBPF program length must be a multiple of {:?} octets",
             ebpf::INSN_SIZE

src/ebpf.rs

@@ -616,7 +616,7 @@ pub fn get_insn(prog: &[u8], idx: usize) -> Insn {
 /// ]);
 /// ```
 pub fn to_insn_vec(prog: &[u8]) -> Vec<Insn> {
-    if prog.len() % INSN_SIZE != 0 {
+    if !prog.len().is_multiple_of(INSN_SIZE) {
         panic!(
             "Error: eBPF program length must be a multiple of {INSN_SIZE:?} octets"
         );

src/insn_builder.rs

@@ -110,72 +110,72 @@ impl BpfCode {
     }
 
     /// create ADD instruction
-    pub fn add(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn add(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::Add)
     }
 
     /// create SUB instruction
-    pub fn sub(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn sub(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::Sub)
     }
 
     /// create MUL instruction
-    pub fn mul(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn mul(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::Mul)
     }
 
     /// create DIV instruction
-    pub fn div(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn div(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::Div)
     }
 
     /// create OR instruction
-    pub fn bit_or(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn bit_or(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::BitOr)
     }
 
     /// create AND instruction
-    pub fn bit_and(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn bit_and(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::BitAnd)
     }
 
     /// create LSHIFT instruction
-    pub fn left_shift(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn left_shift(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::LShift)
     }
 
     /// create RSHIFT instruction
-    pub fn right_shift(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn right_shift(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::RShift)
     }
 
     /// create NEGATE instruction
-    pub fn negate(&mut self, arch: Arch) -> Move {
+    pub fn negate(&mut self, arch: Arch) -> Move<'_> {
         self.mov_internal(Source::Imm, arch, OpBits::Negate)
     }
 
     /// create MOD instruction
-    pub fn modulo(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn modulo(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::Mod)
     }
 
     /// create XOR instruction
-    pub fn bit_xor(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn bit_xor(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::BitXor)
     }
 
     /// create MOV instruction
-    pub fn mov(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn mov(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::Mov)
     }
 
     /// create SIGNED RSHIFT instruction
-    pub fn signed_right_shift(&mut self, source: Source, arch: Arch) -> Move {
+    pub fn signed_right_shift(&mut self, source: Source, arch: Arch) -> Move<'_> {
         self.mov_internal(source, arch, OpBits::SignRShift)
     }
 
     #[inline]
-    fn mov_internal(&mut self, source: Source, arch_bits: Arch, op_bits: OpBits) -> Move {
+    fn mov_internal(&mut self, source: Source, arch_bits: Arch, op_bits: OpBits) -> Move<'_> {
         Move {
             bpf_code: self,
             src_bit: source,
@@ -192,7 +192,7 @@ impl BpfCode {
     }
 
     /// create byte swap instruction
-    pub fn swap_bytes(&mut self, endian: Endian) -> SwapBytes {
+    pub fn swap_bytes(&mut self, endian: Endian) -> SwapBytes<'_> {
         SwapBytes {
             bpf_code: self,
             endian,
@@ -207,27 +207,27 @@ impl BpfCode {
     }
 
     /// create LOAD instruction, IMMEDIATE is the source
-    pub fn load(&mut self, mem_size: MemSize) -> Load {
+    pub fn load(&mut self, mem_size: MemSize) -> Load<'_> {
         self.load_internal(mem_size, Addressing::Imm, BPF_LD)
     }
 
     /// create ABSOLUTE LOAD instruction
-    pub fn load_abs(&mut self, mem_size: MemSize) -> Load {
+    pub fn load_abs(&mut self, mem_size: MemSize) -> Load<'_> {
         self.load_internal(mem_size, Addressing::Abs, BPF_LD)
     }
 
     /// create INDIRECT LOAD instruction
-    pub fn load_ind(&mut self, mem_size: MemSize) -> Load {
+    pub fn load_ind(&mut self, mem_size: MemSize) -> Load<'_> {
         self.load_internal(mem_size, Addressing::Ind, BPF_LD)
     }
 
     /// create LOAD instruction, MEMORY is the source
-    pub fn load_x(&mut self, mem_size: MemSize) -> Load {
+    pub fn load_x(&mut self, mem_size: MemSize) -> Load<'_> {
         self.load_internal(mem_size, Addressing::Mem, BPF_LDX)
     }
 
     #[inline]
-    fn load_internal(&mut self, mem_size: MemSize, addressing: Addressing, source: u8) -> Load {
+    fn load_internal(&mut self, mem_size: MemSize, addressing: Addressing, source: u8) -> Load<'_> {
         Load {
             bpf_code: self,
             addressing,
@@ -244,17 +244,17 @@ impl BpfCode {
     }
 
     /// creates STORE instruction, IMMEDIATE is the source
-    pub fn store(&mut self, mem_size: MemSize) -> Store {
+    pub fn store(&mut self, mem_size: MemSize) -> Store<'_> {
         self.store_internal(mem_size, BPF_IMM)
     }
 
     /// creates STORE instruction, MEMORY is the source
-    pub fn store_x(&mut self, mem_size: MemSize) -> Store {
+    pub fn store_x(&mut self, mem_size: MemSize) -> Store<'_> {
         self.store_internal(mem_size, BPF_MEM | BPF_STX)
     }
 
     #[inline]
-    fn store_internal(&mut self, mem_size: MemSize, source: u8) -> Store {
+    fn store_internal(&mut self, mem_size: MemSize, source: u8) -> Store<'_> {
         Store {
             bpf_code: self,
             mem_size,
@@ -270,12 +270,12 @@ impl BpfCode {
     }
 
     /// create unconditional JMP instruction
-    pub fn jump_unconditional(&mut self) -> Jump {
+    pub fn jump_unconditional(&mut self) -> Jump<'_> {
         self.jump_conditional(Cond::Abs, Source::Imm)
     }
 
     /// create conditional JMP instruction
-    pub fn jump_conditional(&mut self, cond: Cond, src_bit: Source) -> Jump {
+    pub fn jump_conditional(&mut self, cond: Cond, src_bit: Source) -> Jump<'_> {
         Jump {
             bpf_code: self,
             cond,
@@ -291,7 +291,7 @@ impl BpfCode {
     }
 
     /// create CALL instruction
-    pub fn call(&mut self) -> FunctionCall {
+    pub fn call(&mut self) -> FunctionCall<'_> {
         FunctionCall {
             bpf_code: self,
             insn: Insn {
@@ -305,7 +305,7 @@ impl BpfCode {
     }
 
     /// create EXIT instruction
-    pub fn exit(&mut self) -> Exit {
+    pub fn exit(&mut self) -> Exit<'_> {
         Exit {
             bpf_code: self,
             insn: Insn {

src/interpreter.rs

@@ -37,7 +37,7 @@ fn check_mem(
         }
     }
 
-    Err(Error::new(ErrorKind::Other, format!(
+    Err(Error::other(format!(
         "Error: out of bounds memory {} (insn #{:?}), addr {:#x}, size {:?}\nmbuff: {:#x}/{:#x}, mem: {:#x}/{:#x}, stack: {:#x}/{:#x}",
         access_type, insn_ptr, addr, len,
         mbuff.as_ptr() as u64, mbuff.len(),
@@ -59,8 +59,7 @@ pub fn execute_program(
 
     let (prog, stack_usage) = match prog_ {
         Some(prog) => (prog, stack_usage.unwrap()),
-        None => Err(Error::new(
-            ErrorKind::Other,
+        None => Err(Error::other(
             "Error: No program set, call prog_set() to load one",
         ))?,
     };
@@ -405,8 +404,7 @@ pub fn execute_program(
                         if let Some(function) = helpers.get(&(insn.imm as u32)) {
                             reg[0] = function(reg[1], reg[2], reg[3], reg[4], reg[5]);
                         } else {
-                            Err(Error::new(
-                                ErrorKind::Other,
+                            Err(Error::other(
                                 format!(
                                     "Error: unknown helper function (id: {:#x})",
                                     insn.imm as u32
@@ -417,8 +415,7 @@ pub fn execute_program(
                     // eBPF-to-eBPF call
                     1 => {
                         if stack_frame_idx >= MAX_CALL_DEPTH {
-                            Err(Error::new(
-                                ErrorKind::Other,
+                            Err(Error::other(
                                 format!(
                                     "Error: too many nested calls (max: {MAX_CALL_DEPTH})"
                                 )
@@ -434,8 +431,7 @@ pub fn execute_program(
                         insn_ptr += insn.imm as usize;
                     }
                     _ => {
-                        Err(Error::new(
-                            ErrorKind::Other,
+                        Err(Error::other(
                             format!("Error: unsupported call type #{} (insn #{})",
                                 _src,
                                 insn_ptr-1

src/jit.rs

@@ -7,7 +7,9 @@
 
 #![allow(clippy::single_match)]
 
-use crate::{ebpf, format, vec, Error, ErrorKind, HashMap, Vec};
+use crate::{ebpf, format, vec, Error, HashMap, Vec};
+#[cfg(not(feature = "std"))]
+use crate::ErrorKind;
 use core::fmt::Error as FormatterError;
 use core::fmt::Formatter;
 use core::mem;
@@ -921,8 +923,7 @@ impl JitCompiler {
                                 self.emit_mov(mem, R9, RCX);
                                 self.emit_call(mem, *helper as usize);
                             } else {
-                                Err(Error::new(
-                                    ErrorKind::Other,
+                                Err(Error::other(
                                     format!(
                                         "[JIT] Error: unknown helper function (id: {:#x})",
                                         insn.imm as u32
@@ -935,8 +936,7 @@ impl JitCompiler {
                             self.emit_local_call(mem, target_pc);
                         }
                         _ => {
-                            Err(Error::new(
-                                ErrorKind::Other,
+                            Err(Error::other(
                                 format!(
                                     "[JIT] Error: unexpected call type #{:?} (insn #{insn_ptr:?})",
                                     insn.src
@@ -951,8 +951,7 @@ impl JitCompiler {
                 }
 
                 _                => {
-                    Err(Error::new(
-                        ErrorKind::Other,
+                    Err(Error::other(
                         format!(
                             "[JIT] Error: unknown eBPF opcode {:#2x} (insn #{insn_ptr:?})",
                             insn.opc

src/lib.rs

@@ -505,8 +505,7 @@ impl<'a> EbpfVmMbuff<'a> {
     pub fn jit_compile(&mut self) -> Result<(), Error> {
         let prog = match self.prog {
             Some(prog) => prog,
-            None => Err(Error::new(
-                ErrorKind::Other,
+            None => Err(Error::other(
                 "Error: No program set, call prog_set() to load one",
             ))?,
         };
@@ -612,8 +611,7 @@ impl<'a> EbpfVmMbuff<'a> {
                 0,
                 0,
             )),
-            None => Err(Error::new(
-                ErrorKind::Other,
+            None => Err(Error::other(
                 "Error: program has not been JIT-compiled",
             )),
         }
@@ -1095,7 +1093,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
         let l = self.mbuff.buffer.len();
         // Can this ever happen? Probably not, should be ensured at mbuff creation.
         if self.mbuff.data_offset + 8 > l || self.mbuff.data_end_offset + 8 > l {
-            Err(Error::new(ErrorKind::Other, format!("Error: buffer too small ({:?}), cannot use data_offset {:?} and data_end_offset {:?}",
+            Err(Error::other(format!("Error: buffer too small ({:?}), cannot use data_offset {:?} and data_end_offset {:?}",
             l, self.mbuff.data_offset, self.mbuff.data_end_offset)))?;
         }
         LittleEndian::write_u64(
@@ -1136,8 +1134,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
     pub fn jit_compile(&mut self) -> Result<(), Error> {
         let prog = match self.parent.prog {
             Some(prog) => prog,
-            None => Err(Error::new(
-                ErrorKind::Other,
+            None => Err(Error::other(
                 "Error: No program set, call prog_set() to load one",
             ))?,
         };
@@ -1233,8 +1230,7 @@ impl<'a> EbpfVmFixedMbuff<'a> {
                 self.mbuff.data_offset,
                 self.mbuff.data_end_offset,
             )),
-            None => Err(Error::new(
-                ErrorKind::Other,
+            None => Err(Error::other(
                 "Error: program has not been JIT-compiled",
             )),
         }
@@ -1656,8 +1652,7 @@ impl<'a> EbpfVmRaw<'a> {
     pub fn jit_compile(&mut self) -> Result<(), Error> {
         let prog = match self.parent.prog {
             Some(prog) => prog,
-            None => Err(Error::new(
-                ErrorKind::Other,
+            None => Err(Error::other(
                 "Error: No program set, call prog_set() to load one",
             ))?,
         };

src/verifier.rs

@@ -23,11 +23,11 @@ use crate::lib::*;
 
 fn reject<S: AsRef<str>>(msg: S) -> Result<(), Error> {
     let full_msg = format!("[Verifier] Error: {}", msg.as_ref());
-    Err(Error::new(ErrorKind::Other, full_msg))
+    Err(Error::other(full_msg))
 }
 
 fn check_prog_len(prog: &[u8]) -> Result<(), Error> {
-    if prog.len() % ebpf::INSN_SIZE != 0 {
+    if !prog.len().is_multiple_of(ebpf::INSN_SIZE) {
         reject(format!(
             "eBPF program length must be a multiple of {:?} octets",
             ebpf::INSN_SIZE

tests/misc.rs

@@ -18,7 +18,7 @@ extern crate rbpf;
 use rbpf::assembler::assemble;
 #[cfg(feature = "std")]
 use rbpf::helpers;
-use rbpf::lib::{Error, ErrorKind};
+use rbpf::lib::Error;
 
 // The following two examples have been compiled from C with the following command:
 //
@@ -658,7 +658,7 @@ fn verifier_success(_prog: &[u8]) -> Result<(), Error> {
 }
 
 fn verifier_fail(_prog: &[u8]) -> Result<(), Error> {
-    Err(Error::new(ErrorKind::Other, "Gaggablaghblagh!"))
+    Err(Error::other("Gaggablaghblagh!"))
 }
 
 #[test]