Pin AFLplusplus ref to final Apache2 version

Cargo.toml

@@ -207,6 +207,7 @@ struct_field_names = "allow"        # ????
 too_many_lines = "allow"
 type_repetition_in_bounds = "allow"
 unreadable_literal = "allow"
+extra_unused_lifetimes = "allow"    # TypedBuilder derive generates unused lifetimes
 unsafe_derive_deserialize = "allow"
 used_underscore_binding = "allow"
 

crates/libafl/src/lib.rs

@@ -85,8 +85,8 @@ pub mod prelude {
     #![expect(ambiguous_glob_reexports)]
 
     pub use super::{
-        corpus::*, events::*, executors::*, feedbacks::*, fuzzer::*, generators::*, inputs::*,
-        monitors::*, mutators::*, observers::*, schedulers::*, stages::*, state::*, *,
+        corpus::*, events::*, executors::*, feedbacks::*, generators::*, inputs::*, monitors::*,
+        mutators::*, observers::*, schedulers::*, stages::*, state::*, *,
     };
 }
 

crates/libafl/src/monitors/stats/manager.rs

@@ -80,7 +80,7 @@ impl ClientStatsManager {
             if self
                 .sorted_client_ids
                 .last()
-                .map_or(true, |last| *last < client_id)
+                .is_none_or(|last| *last < client_id)
             {
                 self.sorted_client_ids.push(client_id);
             } else if let Err(idx) = self.sorted_client_ids.binary_search(&client_id) {

crates/libafl/src/stages/afl_stats.rs

@@ -541,7 +541,7 @@ where
             let tmp_file = stats_file_path.with_extension("tmp");
 
             std::fs::write(&tmp_file, stats.to_string())?;
-            _ = std::fs::rename(&tmp_file, stats_file_path)?;
+            std::fs::rename(&tmp_file, stats_file_path)?;
         }
         Ok(())
     }

crates/libafl_qemu/src/emu/drivers/mod.rs

@@ -527,7 +527,7 @@ where
     fn try_from(value: EmulatorDriverResult<C>) -> Result<Self, Self::Error> {
         match value {
             EmulatorDriverResult::ReturnToClient(unhandled_qemu_exit) => {
-                Err(format!("Unhandled QEMU exit: {:?}", &unhandled_qemu_exit))
+                Err(format!("Unhandled QEMU exit: {unhandled_qemu_exit:?}"))
             }
             EmulatorDriverResult::EndOfRun(exit_kind) => Ok(exit_kind),
             EmulatorDriverResult::ShutdownRequest => {

crates/libafl_sugar/src/forkserver.rs

@@ -250,14 +250,14 @@ impl ForkserverBytesCoverageSugar<'_> {
                         state.corpus().count()
                     );
                 } else {
-                    log::info!("Loading from {:?}", &self.input_dirs);
+                    log::info!("Loading from {:?}", self.input_dirs);
                     // Load from disk
                     state
                         .load_initial_inputs(&mut fuzzer, &mut executor, &mut mgr, self.input_dirs)
                         .unwrap_or_else(|err| {
                             panic!(
                                 "Failed to load initial corpus at {:?}: {err:?}",
-                                &self.input_dirs
+                                self.input_dirs
                             );
                         });
                     log::info!("We imported {} inputs from disk.", state.corpus().count());

crates/libafl_sugar/src/inprocess.rs

@@ -258,12 +258,12 @@ where
                         state.corpus().count()
                     );
                 } else {
-                    log::info!("Loading from {:?}", &self.input_dirs);
+                    log::info!("Loading from {:?}", self.input_dirs);
                     // Load from disk
                     state
                         .load_initial_inputs(&mut fuzzer, &mut executor, &mut mgr, self.input_dirs)
                         .unwrap_or_else(|_| {
-                            panic!("Failed to load initial corpus at {:?}", &self.input_dirs);
+                            panic!("Failed to load initial corpus at {:?}", self.input_dirs);
                         });
                     log::info!("We imported {} inputs from disk.", state.corpus().count());
                 }

crates/libafl_sugar/src/qemu.rs

@@ -144,11 +144,11 @@ where
 
         let mut out_dir = self.output_dir.clone();
         if fs::create_dir(&out_dir).is_err() {
-            log::info!("Out dir at {} already exists.", &out_dir.display());
+            log::info!("Out dir at {} already exists.", out_dir.display());
             assert!(
                 out_dir.is_dir(),
                 "Out dir at {} is not a valid directory!",
-                &out_dir.display()
+                out_dir.display()
             );
         }
         let mut crashes = out_dir.clone();
@@ -311,7 +311,7 @@ where
                             state.corpus().count()
                         );
                     } else {
-                        log::info!("Loading from {:?}", &self.input_dirs);
+                        log::info!("Loading from {:?}", self.input_dirs);
                         // Load from disk
                         state
                             .load_initial_inputs(
@@ -321,7 +321,7 @@ where
                                 self.input_dirs,
                             )
                             .unwrap_or_else(|_| {
-                                panic!("Failed to load initial corpus at {:?}", &self.input_dirs);
+                                panic!("Failed to load initial corpus at {:?}", self.input_dirs);
                             });
                         log::info!("We imported {} inputs from disk.", state.corpus().count());
                     }
@@ -439,7 +439,7 @@ where
                             state.corpus().count()
                         );
                     } else {
-                        log::info!("Loading from {:?}", &self.input_dirs);
+                        log::info!("Loading from {:?}", self.input_dirs);
                         // Load from disk
                         state
                             .load_initial_inputs(
@@ -449,7 +449,7 @@ where
                                 self.input_dirs,
                             )
                             .unwrap_or_else(|_| {
-                                panic!("Failed to load initial corpus at {:?}", &self.input_dirs);
+                                panic!("Failed to load initial corpus at {:?}", self.input_dirs);
                             });
                         log::info!("We imported {} inputs from disk.", state.corpus().count());
                     }

crates/libafl_tinyinst/src/executor.rs

@@ -319,7 +319,7 @@ impl<SP: ShMemProvider> TinyInstExecutorBuilder<'_, SP> {
             return Err(Error::unknown("No input file or shmem provided"));
         }
 
-        log::info!("tinyinst args: {:#?}", &self.tinyinst_args);
+        log::info!("tinyinst args: {:#?}", self.tinyinst_args);
 
         let cur_input = InputFile::create(INPUTFILE_STD)?;
         let tinyinst = TinyInst::new(

crates/shmem_providers/src/lib.rs

@@ -1875,6 +1875,7 @@ where
         }
     }
 
+    #[allow(clippy::std_instead_of_core)] // core::io::IoSlice is unstable (core_io)
     fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
         match self.empty_slice_mut().write_vectored(bufs) {
             Ok(w) => {