Clippy (#1105)

libafl/src/bolts/build_id.rs

@@ -58,7 +58,7 @@ fn from_exe<H: Hasher>(mut hasher: H) -> Result<H, ()> {
             return Err(());
         }
         let file = File::open(env::current_exe().map_err(drop)?).map_err(drop)?;
-        let _ = io::copy(&mut &file, &mut HashWriter(&mut hasher)).map_err(drop)?;
+        let _: u64 = io::copy(&mut &file, &mut HashWriter(&mut hasher)).map_err(drop)?;
         Ok(hasher)
     }
     #[cfg(target_arch = "wasm32")]

libafl/src/bolts/os/pipes.rs

@@ -34,7 +34,7 @@ impl Pipe {
     /// Close the read end of a pipe
     pub fn close_read_end(&mut self) {
         if let Some(read_end) = self.read_end {
-            let _ = close(read_end);
+            let _: Result<(), nix::errno::Errno> = close(read_end);
             self.read_end = None;
         }
     }
@@ -42,7 +42,7 @@ impl Pipe {
     /// Close the write end of a pipe
     pub fn close_write_end(&mut self) {
         if let Some(write_end) = self.write_end {
-            let _ = close(write_end);
+            let _: Result<(), nix::errno::Errno> = close(write_end);
             self.write_end = None;
         }
     }
@@ -102,10 +102,10 @@ impl Write for Pipe {
 impl Drop for Pipe {
     fn drop(&mut self) {
         if let Some(read_end) = self.read_end {
-            let _ = close(read_end);
+            let _: Result<(), nix::errno::Errno> = close(read_end);
         }
         if let Some(write_end) = self.write_end {
-            let _ = close(write_end);
+            let _: Result<(), nix::errno::Errno> = close(write_end);
         }
     }
 }

libafl/src/bolts/ownedref.rs

@@ -39,7 +39,7 @@ impl<'a, T> DownsizeSlice for &'a mut [T] {
     fn downsize(&mut self, len: usize) {
         let mut value = core::mem::take(self);
         value = unsafe { value.get_unchecked_mut(..len) };
-        let _ = core::mem::replace(self, value);
+        let _: &mut [T] = core::mem::replace(self, value);
     }
 }
 

libafl/src/corpus/cached.rs

@@ -71,7 +71,7 @@ where
     fn get(&self, idx: CorpusId) -> Result<&RefCell<Testcase<I>>, Error> {
         let testcase = { self.inner.get(idx)? };
         if testcase.borrow().input().is_none() {
-            let _ = testcase.borrow_mut().load_input()?;
+            let _: &I = testcase.borrow_mut().load_input()?;
             let mut borrowed_num = 0;
             while self.cached_indexes.borrow().len() >= self.cache_max_len {
                 let removed = self.cached_indexes.borrow_mut().pop_front().unwrap();

libafl/src/executors/forkserver.rs

@@ -492,7 +492,8 @@ where
             self.executor.forkserver_mut().set_last_run_timed_out(1);
 
             // We need to kill the child in case he has timed out, or we can't get the correct pid in the next call to self.executor.forkserver_mut().read_st()?
-            let _ = kill(self.executor.forkserver().child_pid(), self.signal);
+            let _: Result<(), nix::errno::Errno> =
+                kill(self.executor.forkserver().child_pid(), self.signal);
             let (recv_status_len, _) = self.executor.forkserver_mut().read_st()?;
             if recv_status_len != 4 {
                 return Err(Error::unknown("Could not kill timed-out child".to_string()));

libafl/src/executors/inprocess.rs

@@ -1668,7 +1668,7 @@ where
                         );
 
                         // log::info!("Set timer! {:#?} {timerid:#?}", self.itimerspec);
-                        let _ = libc::timer_settime(
+                        let _: i32 = libc::timer_settime(
                             timerid,
                             0,
                             addr_of_mut!(self.itimerspec),

libafl/src/fuzzer/mod.rs

@@ -504,7 +504,7 @@ where
 
         // several is_interesting implementations collect some data about the run, later used in
         // append_metadata; we *must* invoke is_interesting here to collect it
-        let _ = self
+        let _: bool = self
             .feedback_mut()
             .is_interesting(state, manager, &input, observers, &exit_kind)?;
 

libafl/src/generators/mod.rs

@@ -1,7 +1,6 @@
 //! Generators may generate bytes or, in general, data, for inputs.
 
-use alloc::string::String;
+use alloc::{string::String, vec::Vec};
-use alloc::vec::Vec;
 use core::marker::PhantomData;
 
 use crate::{

libafl/src/monitors/mod.rs

@@ -115,7 +115,7 @@ impl ClientStats {
             .checked_sub(self.last_window_time)
             .map_or(0, |d| d.as_secs());
         if diff > CLIENT_STATS_TIME_WINDOW_SECS {
-            let _ = self.execs_per_sec(cur_time);
+            let _: f64 = self.execs_per_sec(cur_time);
             self.last_window_time = cur_time;
             self.last_window_executions = self.executions;
         }

libafl/src/stages/concolic.rs

@@ -384,7 +384,8 @@ where
                     input_copy.bytes_mut()[index] = new_byte;
                 }
                 // Time is measured directly the `evaluate_input` function
-                let _ = fuzzer.evaluate_input(state, executor, manager, input_copy)?;
+                let _: (crate::ExecuteInputResult, Option<CorpusId>) =
+                    fuzzer.evaluate_input(state, executor, manager, input_copy)?;
             }
         }
         Ok(())

libafl/src/state/mod.rs

@@ -17,7 +17,7 @@ use crate::{
         rands::Rand,
         serdeany::{NamedSerdeAnyMap, SerdeAny, SerdeAnyMap},
     },
-    corpus::Corpus,
+    corpus::{Corpus, CorpusId},
     events::{Event, EventFirer, LogSeverity},
     feedbacks::Feedback,
     fuzzer::{Evaluator, ExecuteInputResult},
@@ -471,7 +471,7 @@ where
             log::info!("Loading file {:?} ...", &path);
             let input = loader(fuzzer, self, &path)?;
             if forced {
-                let _ = fuzzer.add_input(self, executor, manager, input)?;
+                let _: CorpusId = fuzzer.add_input(self, executor, manager, input)?;
             } else {
                 let (res, _) = fuzzer.evaluate_input(self, executor, manager, input)?;
                 if res == ExecuteInputResult::None {
@@ -617,7 +617,7 @@ where
         for _ in 0..num {
             let input = generator.generate(self)?;
             if forced {
-                let _ = fuzzer.add_input(self, executor, manager, input)?;
+                let _: CorpusId = fuzzer.add_input(self, executor, manager, input)?;
                 added += 1;
             } else {
                 let (res, _) = fuzzer.evaluate_input(self, executor, manager, input)?;

libafl_qemu/libafl_qemu_build/src/build.rs

@@ -398,7 +398,8 @@ pub fn build(
     println!("cargo:rustc-link-lib=z");
     // if keyutils is available, qemu meson script will compile code with keyutils.
     // therefore, we need to link with keyutils if our system have libkeyutils.
-    let _ = pkg_config::Config::new().probe("libkeyutils");
+    let _: Result<pkg_config::Library, pkg_config::Error> =
+        pkg_config::Config::new().probe("libkeyutils");
 
     if !is_usermode {
         println!("cargo:rustc-link-lib=pixman-1");

libafl_qemu/src/drcov.rs

@@ -42,6 +42,7 @@ pub struct QemuDrCovHelper {
 
 impl QemuDrCovHelper {
     #[must_use]
+    #[allow(clippy::let_underscore_untyped)]
     pub fn new(
         filter: QemuInstrumentationFilter,
         module_mapping: RangeMap<usize, (u16, String)>,

libafl_targets/src/sancov_8bit.rs

@@ -10,6 +10,6 @@ pub static mut COUNTERS_MAPS: Vec<&'static mut [u8]> = Vec::new();
 #[no_mangle]
 #[allow(clippy::cast_sign_loss)]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
-pub fn __sanitizer_cov_8bit_counters_init(start: *mut u8, stop: *mut u8) {
+pub extern "C" fn __sanitizer_cov_8bit_counters_init(start: *mut u8, stop: *mut u8) {
     unsafe { COUNTERS_MAPS.push(from_raw_parts_mut(start, stop.offset_from(start) as usize)) }
 }