rs: apply cargo clippy

Author: jiegec

capstone-rs/examples/demo.rs

@@ -27,7 +27,7 @@ fn arch_example(cs: &mut Capstone, code: &[u8]) -> CsResult<()> {
     println!("Found {} instructions", insns.len());
     for i in insns.iter() {
         println!();
-        println!("{}", i);
+        println!("{i}");
 
         let detail: InsnDetail = cs.insn_detail(i)?;
         let arch_detail: ArchDetail = detail.arch_detail();
@@ -85,7 +85,7 @@ fn example() -> CsResult<()> {
 
     for &mut (arch, ref mut cs, code) in examples.iter_mut() {
         println!("\n*************************************");
-        println!("Architecture {}:", arch);
+        println!("Architecture {arch}:");
         arch_example(cs, code)?;
     }
 
@@ -94,6 +94,6 @@ fn example() -> CsResult<()> {
 
 fn main() {
     if let Err(err) = example() {
-        println!("Error: {}", err);
+        println!("Error: {err}");
     }
 }

capstone-rs/src/error.rs

@@ -129,7 +129,7 @@ mod test {
         ];
 
         for error in errors.iter() {
-            println!("{}", error);
+            println!("{error}");
         }
     }
 }

capstone-rs/src/instruction.rs

@@ -404,9 +404,9 @@ impl Display for Insn<'_> {
     fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
         write!(fmt, "{:#x}: ", self.address())?;
         if let Some(mnemonic) = self.mnemonic() {
-            write!(fmt, "{} ", mnemonic)?;
+            write!(fmt, "{mnemonic} ")?;
             if let Some(op_str) = self.op_str() {
-                write!(fmt, "{}", op_str)?;
+                write!(fmt, "{op_str}")?;
             }
         }
         Ok(())
@@ -545,16 +545,16 @@ impl Display for Instructions<'_> {
         for instruction in self.iter() {
             write!(fmt, "{:x}:\t", instruction.address())?;
             for byte in instruction.bytes() {
-                write!(fmt, " {:02x}", byte)?;
+                write!(fmt, " {byte:02x}")?;
             }
             let remainder = 16 * 3 - instruction.bytes().len() * 3;
             for _ in 0..remainder {
                 write!(fmt, " ")?;
             }
             if let Some(mnemonic) = instruction.mnemonic() {
-                write!(fmt, " {}", mnemonic)?;
+                write!(fmt, " {mnemonic}")?;
                 if let Some(op_str) = instruction.op_str() {
-                    write!(fmt, " {}", op_str)?;
+                    write!(fmt, " {op_str}")?;
                 }
             }
             writeln!(fmt)?;

capstone-rs/src/test.rs

@@ -317,7 +317,7 @@ fn test_instruction_helper(
     bytes: &[u8],
     has_default_syntax: bool,
 ) {
-    println!("{:x?}", insn);
+    println!("{insn:x?}");
 
     // Check mnemonic
     if has_default_syntax && cfg!(feature = "full") {
@@ -908,7 +908,7 @@ fn test_invalid_mode() {
 #[test]
 fn test_capstone_version() {
     let (major, minor) = Capstone::lib_version();
-    println!("Capstone lib version: ({}, {})", major, minor);
+    println!("Capstone lib version: ({major}, {minor})");
     assert!(major > 0 && major < 100, "Invalid major version {}", major);
     assert!(minor < 500, "Invalid minor version {}", minor);
 }
@@ -1885,7 +1885,7 @@ fn test_arch_bpf_cbpf() {
         Ok(ins) => {
             for i in ins.as_ref() {
                 println!();
-                eprintln!("{}", i);
+                eprintln!("{i}");
 
                 let detail: InsnDetail = cs.insn_detail(i).expect("Failed to get insn detail");
                 let arch_detail: ArchDetail = detail.arch_detail();
@@ -1931,7 +1931,7 @@ fn test_arch_bpf_ebpf() {
         Ok(ins) => {
             for i in ins.as_ref() {
                 println!();
-                eprintln!("{}", i);
+                eprintln!("{i}");
 
                 let detail: InsnDetail = cs.insn_detail(i).expect("Failed to get insn detail");
                 let arch_detail: ArchDetail = detail.arch_detail();
@@ -4719,7 +4719,7 @@ fn test_arch_riscv_detail() {
                 &[
                     Reg(RegId(RISCV_REG_X11 as RegIdInt)),
                     Mem(RiscVOpMem(riscv_op_mem {
-                        base: RISCV_REG_X12 as u32,
+                        base: RISCV_REG_X12,
                         disp: 8,
                     })),
                 ],
@@ -4956,7 +4956,7 @@ fn test_issue_175() {
 
     let insns = cs.disasm_all(&[0x0c, 0x44, 0x3b, 0xd5], 0).unwrap();
     for i in insns.as_ref() {
-        let id = cs.insn_detail(&i).unwrap();
+        let id = cs.insn_detail(i).unwrap();
         let ad = id.arch_detail();
         let aarch = ad.aarch64().unwrap();
 

cstool/src/bin/cstool.rs

@@ -28,7 +28,7 @@ where
         match self {
             Ok(t) => t,
             Err(e) => {
-                eprintln!("error: {}", e);
+                eprintln!("error: {e}");
                 exit(1);
             }
         }
@@ -66,7 +66,7 @@ fn unhexed_bytes(input: Vec<u8>) -> Vec<u8> {
     }
 
     if log::max_level() >= log::LevelFilter::Info {
-        let output_hex: Vec<String> = output.iter().map(|x| format!("{:02x}", x)).collect();
+        let output_hex: Vec<String> = output.iter().map(|x| format!("{x:02x}")).collect();
         info!("unhexed_output = {:?}", output_hex);
     }
 
@@ -93,7 +93,7 @@ fn disasm<T: Iterator<Item = ExtraMode>>(
     let mut handle = stdout.lock();
 
     for i in cs.disasm_all(code, addr).expect_exit().iter() {
-        let bytes: Vec<_> = i.bytes().iter().map(|x| format!("{:02x}", x)).collect();
+        let bytes: Vec<_> = i.bytes().iter().map(|x| format!("{x:02x}")).collect();
         let bytes = bytes.join(" ");
         let _ = writeln!(
             &mut handle,
@@ -148,19 +148,19 @@ fn main() {
     // Lowercase arches
     let arches: Vec<Str> = Arch::variants()
         .iter()
-        .map(|x| format!("{}", x).to_lowercase().into())
+        .map(|x| format!("{x}").to_lowercase().into())
         .collect();
 
     // Lowercase modes
     let modes: Vec<Str> = Mode::variants()
         .iter()
-        .map(|x| format!("{}", x).to_lowercase().into())
+        .map(|x| format!("{x}").to_lowercase().into())
         .collect();
 
     // Lowercase extra modes
     let extra_modes: Vec<Str> = ExtraMode::variants()
         .iter()
-        .map(|x| format!("{}", x).to_lowercase().into())
+        .map(|x| format!("{x}").to_lowercase().into())
         .collect();
 
     let matches = Command::new("capstone-rs disassembler tool")