a small cleanup of warns

afl/src/engines/mod.rs

@@ -1,9 +1,7 @@
 //! The engine is the core piece of every good fuzzer
 
 use alloc::boxed::Box;
-use alloc::rc::Rc;
 use alloc::vec::Vec;
-use core::cell::RefCell;
 use core::fmt::Debug;
 use core::marker::PhantomData;
 use hashbrown::HashMap;
@@ -14,7 +12,6 @@ use crate::executors::Executor;
 use crate::feedbacks::Feedback;
 use crate::generators::Generator;
 use crate::inputs::Input;
-use crate::observers::Observer;
 use crate::stages::Stage;
 use crate::utils::{current_milliseconds, Rand};
 use crate::AflError;
@@ -199,10 +196,14 @@ where
             let input = generator.generate(rand)?;
             let fitness = self.evaluate_input(&input, engine)?;
             self.add_if_interesting(corpus, input, fitness)?;
-            engine.events_manager_mut().fire(Event::LoadInitial {
+            engine.events_manager_mut().fire(
-                sender_id: 0,
+                Event::LoadInitial {
-                phantom: PhantomData,
+                    sender_id: 0,
-            }, self, corpus)?;
+                    phantom: PhantomData,
+                },
+                self,
+                corpus,
+            )?;
         }
         engine.events_manager_mut().process(self, corpus)?;
         Ok(())
@@ -324,11 +325,15 @@ where
             let cur = current_milliseconds();
             if cur - last > 60 * 100 {
                 last = cur;
-                engine.events_manager_mut().fire(Event::UpdateStats {
+                engine.events_manager_mut().fire(
-                    sender_id: 0,
+                    Event::UpdateStats {
-                    new_execs: 1,
+                        sender_id: 0,
-                    phantom: PhantomData,
+                        new_execs: 1,
-                }, state, corpus)?; // TODO self.new_execs});
+                        phantom: PhantomData,
+                    },
+                    state,
+                    corpus,
+                )?; // TODO self.new_execs});
             }
         }
     }
@@ -411,7 +416,7 @@ mod tests {
         let executor = InMemoryExecutor::<BytesInput>::new(harness);
         let mut state = State::new();
 
-        let mut events_manager = LoggerEventManager::new(stderr());
+        let events_manager = LoggerEventManager::new(stderr());
 
         let mut engine = Engine::new(executor, events_manager);
         let mut mutator = StdScheduledMutator::new();

afl/src/events/mod.rs

@@ -21,8 +21,8 @@ use crate::corpus::{Corpus, Testcase};
 use crate::engines::State;
 use crate::executors::Executor;
 use crate::inputs::Input;
-use crate::utils::Rand;
 use crate::serde_anymap::{Ptr, PtrMut};
+use crate::utils::Rand;
 use crate::AflError;
 /// Indicate if an event worked or not
 enum BrokerEventResult {
@@ -88,7 +88,7 @@ where
     NewTestcase2 {
         sender_id: u64,
         input: Ptr<'a, I>,
-        observers: PtrMut<'a, crate::observers::observer_serde::NamedSerdeAnyMap>
+        observers: PtrMut<'a, crate::observers::observer_serde::NamedSerdeAnyMap>,
     },
     UpdateStats {
         sender_id: u64,
@@ -262,7 +262,12 @@ where
     fn enabled(&self) -> bool;
 
     /// Fire an Event
-    fn fire<'a>(&mut self, event: Event<'a, C, E, I, R>, state: &mut State<I, R>, corpus: &mut C) -> Result<(), AflError>;
+    fn fire<'a>(
+        &mut self,
+        event: Event<'a, C, E, I, R>,
+        state: &mut State<I, R>,
+        corpus: &mut C,
+    ) -> Result<(), AflError>;
 
     /// Lookup for incoming events and process them.
     /// Return the number of processes events or an error
@@ -295,7 +300,7 @@ where
 {
     writer: W,
     count: usize,
-    phantom: PhantomData<(C, E, I, R)>
+    phantom: PhantomData<(C, E, I, R)>,
 }
 
 #[cfg(feature = "std")]
@@ -312,7 +317,12 @@ where
         true
     }
 
-    fn fire<'a>(&mut self, event: Event<'a, C, E, I, R>, state: &mut State<I, R>, corpus: &mut C) -> Result<(), AflError> {
+    fn fire<'a>(
+        &mut self,
+        event: Event<'a, C, E, I, R>,
+        state: &mut State<I, R>,
+        corpus: &mut C,
+    ) -> Result<(), AflError> {
         match event.handle_in_broker(state, corpus)? {
             BrokerEventResult::Forward => event.handle_in_client(state, corpus)?,
             // Ignore broker-only events
@@ -321,7 +331,7 @@ where
         Ok(())
     }
 
-    fn process(&mut self, state: &mut State<I, R>, corpus: &mut C) -> Result<usize, AflError> {
+    fn process(&mut self, _state: &mut State<I, R>, _corpus: &mut C) -> Result<usize, AflError> {
         let c = self.count;
         self.count = 0;
         Ok(c)
@@ -342,7 +352,7 @@ where
         Self {
             writer: writer,
             count: 0,
-            phantom: PhantomData
+            phantom: PhantomData,
         }
     }
 }

afl/src/executors/inmemory.rs

@@ -3,8 +3,8 @@ use core::ptr;
 
 use crate::executors::{Executor, ExitKind};
 use crate::inputs::Input;
-use crate::observers::Observer;
 use crate::observers::observer_serde::NamedSerdeAnyMap;
+use crate::observers::Observer;
 use crate::AflError;
 
 type HarnessFunction<I> = fn(&dyn Executor<I>, &[u8]) -> ExitKind;

afl/src/executors/mod.rs

@@ -1,8 +1,8 @@
 pub mod inmemory;
 
 use crate::inputs::Input;
-use crate::observers::Observer;
 use crate::observers::observer_serde::NamedSerdeAnyMap;
+use crate::observers::Observer;
 use crate::AflError;
 
 pub enum ExitKind {

afl/src/feedbacks/mod.rs

@@ -2,10 +2,10 @@ use alloc::vec::Vec;
 use core::marker::PhantomData;
 use num::Integer;
 
-use crate::corpus::{Testcase, TestcaseMetadata};
+use crate::corpus::Testcase;
 use crate::inputs::Input;
-use crate::observers::{MapObserver, Observer};
 use crate::observers::observer_serde::NamedSerdeAnyMap;
+use crate::observers::MapObserver;
 use crate::AflError;
 
 pub trait Feedback<I>
@@ -13,11 +13,7 @@ where
     I: Input,
 {
     /// is_interesting should return the "Interestingness" from 0 to 255 (percent times 2.55)
-    fn is_interesting(
+    fn is_interesting(&mut self, input: &I, observers: &NamedSerdeAnyMap) -> Result<u32, AflError>;
-        &mut self,
-        input: &I,
-        observers: &NamedSerdeAnyMap,
-    ) -> Result<u32, AflError>;
 
     /// Append to the testcase the generated metadata in case of a new corpus item
     fn append_metadata(&mut self, _testcase: &mut Testcase<I>) -> Result<(), AflError> {

afl/src/observers/mod.rs

@@ -27,18 +27,17 @@ pub trait Observer: SerdeAny + 'static {
 crate::create_serde_registry_for_trait!(observer_serde, crate::observers::Observer);
 
 #[derive(Serialize, Deserialize)]
-pub struct NopObserver {
+pub struct NopObserver {}
-
-}
 impl Observer for NopObserver {
     fn name(&self) -> &'static str {
         "aa"
     }
-    
+
-    fn reset(&mut self) -> Result<(), AflError> { Ok(()) }
+    fn reset(&mut self) -> Result<(), AflError> {
+        Ok(())
+    }
 }
-impl SerdeAny for NopObserver
+impl SerdeAny for NopObserver {
-{
     fn as_any(&self) -> &dyn Any {
         self
     }

afl/src/serde_anymap.rs

@@ -1,12 +1,7 @@
-use hashbrown::HashMap;
 use serde::{Deserialize, Serialize};
 
 use alloc::boxed::Box;
 use core::any::{Any, TypeId};
-use core::default::Default;
-use hashbrown::hash_map::{Keys, Values, ValuesMut};
-
-use crate::AflError;
 
 pub fn pack_type_id(id: u64) -> TypeId {
     unsafe { *(&id as *const u64 as *const TypeId) }
@@ -37,11 +32,17 @@ where
 pub type DeserializeCallback<B> =
     fn(&mut dyn erased_serde::Deserializer) -> Result<Box<B>, erased_serde::Error>;
 
-pub struct DeserializeCallbackSeed<B> where B: ?Sized {
+pub struct DeserializeCallbackSeed<B>
+where
+    B: ?Sized,
+{
     pub cb: DeserializeCallback<B>,
 }
 
-impl<'de, B> serde::de::DeserializeSeed<'de> for DeserializeCallbackSeed<B> where B: ?Sized {
+impl<'de, B> serde::de::DeserializeSeed<'de> for DeserializeCallbackSeed<B>
+where
+    B: ?Sized,
+{
     type Value = Box<B>;
 
     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
@@ -56,20 +57,21 @@ impl<'de, B> serde::de::DeserializeSeed<'de> for DeserializeCallbackSeed<B> wher
 #[macro_export]
 macro_rules! create_serde_registry_for_trait {
     ($mod_name:ident, $trait_name:path) => {
-        
         pub mod $mod_name {
-        
-            use alloc::boxed::Box;
-            use core::fmt;
-            use core::any::{Any, TypeId};
-            use serde::{Deserialize, Serialize};
-          
-            use hashbrown::HashMap;
-            use hashbrown::hash_map::{Keys, Values, ValuesMut};
 
+            use alloc::boxed::Box;
+            use core::any::{Any, TypeId};
+            use core::fmt;
+            use serde::{Deserialize, Serialize};
+
+            use hashbrown::hash_map::{Keys, Values, ValuesMut};
+            use hashbrown::HashMap;
+
+            use $crate::serde_anymap::{
+                pack_type_id, unpack_type_id, DeserializeCallback, DeserializeCallbackSeed,
+            };
             use $crate::AflError;
-            use $crate::serde_anymap::{DeserializeCallback, DeserializeCallbackSeed, pack_type_id, unpack_type_id};
+
-          
             pub struct BoxDynVisitor {}
             impl<'de> serde::de::Visitor<'de> for BoxDynVisitor {
                 type Value = Box<dyn $trait_name>;
@@ -82,7 +84,7 @@ macro_rules! create_serde_registry_for_trait {
                 where
                     V: serde::de::SeqAccess<'de>,
                 {
-                    /*let id: u64 = visitor.next_element()?.unwrap();
+                    let id: u64 = visitor.next_element()?.unwrap();
                     let cb = unsafe {
                         *REGISTRY
                             .deserializers
@@ -90,14 +92,13 @@ macro_rules! create_serde_registry_for_trait {
                             .unwrap()
                             .get(&id)
                             .expect("Cannot deserialize an unregistered type")
-                    };*/
+                    };
-                    //let seed = DeserializeCallbackSeed::<dyn $trait_name> { cb: cb };
+                    let seed = DeserializeCallbackSeed::<dyn $trait_name> { cb: cb };
-                    //let obj: Self::Value = visitor.next_element_seed(seed)?.unwrap();
+                    let obj: Self::Value = visitor.next_element_seed(seed)?.unwrap();
-                    let obj = Box::new(crate::observers::NopObserver::new());
                     Ok(obj)
                 }
             }
-          
+
             struct Registry {
                 deserializers: Option<HashMap<u64, DeserializeCallback<dyn $trait_name>>>,
                 finalized: bool,
@@ -112,7 +113,8 @@ macro_rules! create_serde_registry_for_trait {
                         panic!("Registry is already finalized!");
                     }
 
-                    let deserializers = self.deserializers.get_or_insert_with(|| HashMap::default());
+                    let deserializers =
+                        self.deserializers.get_or_insert_with(|| HashMap::default());
                     deserializers.insert(unpack_type_id(TypeId::of::<T>()), |de| {
                         Ok(Box::new(erased_serde::deserialize::<T>(de)?))
                     });
@@ -145,15 +147,13 @@ macro_rules! create_serde_registry_for_trait {
                     }
                 }
             }
-              
+
             #[derive(Serialize, Deserialize)]
-            pub struct SerdeAnyMap
+            pub struct SerdeAnyMap {
-            {
                 map: HashMap<u64, Box<dyn $trait_name>>,
             }
 
-            impl SerdeAnyMap
+            impl SerdeAnyMap {
-            {
                 pub fn get<T>(&self) -> Option<&T>
                 where
                     T: $trait_name,
@@ -198,22 +198,18 @@ macro_rules! create_serde_registry_for_trait {
                 }
             }
 
-            impl Default for SerdeAnyMap
+            impl Default for SerdeAnyMap {
-            {
                 fn default() -> Self {
                     Self::new()
                 }
             }
 
-
             #[derive(Serialize, Deserialize)]
-            pub struct NamedSerdeAnyMap
+            pub struct NamedSerdeAnyMap {
-            {
                 map: HashMap<u64, HashMap<u64, Box<dyn $trait_name>>>,
             }
 
-            impl NamedSerdeAnyMap
+            impl NamedSerdeAnyMap {
-            {
                 pub fn get<T>(&self, name: &'static str) -> Option<&T>
                 where
                     T: Any,
@@ -226,7 +222,11 @@ macro_rules! create_serde_registry_for_trait {
                     }
                 }
 
-                pub fn by_typeid(&self, name: &'static str, typeid: &TypeId) -> Option<&dyn $trait_name> {
+                pub fn by_typeid(
+                    &self,
+                    name: &'static str,
+                    typeid: &TypeId,
+                ) -> Option<&dyn $trait_name> {
                     match self.map.get(&unpack_type_id(*typeid)) {
                         None => None,
                         Some(h) => h
@@ -247,7 +247,11 @@ macro_rules! create_serde_registry_for_trait {
                     }
                 }
 
-                pub fn by_typeid_mut(&mut self, name: &'static str, typeid: &TypeId) -> Option<&mut dyn $trait_name> {
+                pub fn by_typeid_mut(
+                    &mut self,
+                    name: &'static str,
+                    typeid: &TypeId,
+                ) -> Option<&mut dyn $trait_name> {
                     match self.map.get_mut(&unpack_type_id(*typeid)) {
                         None => None,
                         Some(h) => h
@@ -256,20 +260,34 @@ macro_rules! create_serde_registry_for_trait {
                     }
                 }
 
-                pub fn get_all<T>(&self) -> Option<core::iter::Map<Values<'_, u64, Box<dyn $trait_name>>, fn(&Box<dyn $trait_name>) -> &T>>
+                pub fn get_all<T>(
+                    &self,
+                ) -> Option<
+                    core::iter::Map<
+                        Values<'_, u64, Box<dyn $trait_name>>,
+                        fn(&Box<dyn $trait_name>) -> &T,
+                    >,
+                >
                 where
                     T: Any,
                 {
                     match self.map.get(&unpack_type_id(TypeId::of::<T>())) {
                         None => None,
-                        Some(h) => Some(h.values().map(|x| x.as_any().downcast_ref::<T>().unwrap())),
+                        Some(h) => {
+                            Some(h.values().map(|x| x.as_any().downcast_ref::<T>().unwrap()))
+                        }
                     }
                 }
 
                 pub fn all_by_typeid(
                     &self,
                     typeid: &TypeId,
-                ) -> Option<core::iter::Map<Values<'_, u64, Box<dyn $trait_name>>, fn(&Box<dyn $trait_name>) -> &dyn $trait_name>> {
+                ) -> Option<
+                    core::iter::Map<
+                        Values<'_, u64, Box<dyn $trait_name>>,
+                        fn(&Box<dyn $trait_name>) -> &dyn $trait_name,
+                    >,
+                > {
                     match self.map.get(&unpack_type_id(*typeid)) {
                         None => None,
                         Some(h) => Some(h.values().map(|x| x.as_ref())),
@@ -278,7 +296,12 @@ macro_rules! create_serde_registry_for_trait {
 
                 pub fn get_all_mut<T>(
                     &mut self,
-                ) -> Option<core::iter::Map<ValuesMut<'_, u64, Box<dyn $trait_name>>, fn(&mut Box<dyn $trait_name>) -> &mut T>>
+                ) -> Option<
+                    core::iter::Map<
+                        ValuesMut<'_, u64, Box<dyn $trait_name>>,
+                        fn(&mut Box<dyn $trait_name>) -> &mut T,
+                    >,
+                >
                 where
                     T: Any,
                 {
@@ -294,7 +317,12 @@ macro_rules! create_serde_registry_for_trait {
                 pub fn all_by_typeid_mut(
                     &mut self,
                     typeid: &TypeId,
-                ) -> Option<core::iter::Map<ValuesMut<'_, u64, Box<dyn $trait_name>>, fn(&mut Box<dyn $trait_name>) -> &mut dyn $trait_name>> {
+                ) -> Option<
+                    core::iter::Map<
+                        ValuesMut<'_, u64, Box<dyn $trait_name>>,
+                        fn(&mut Box<dyn $trait_name>) -> &mut dyn $trait_name,
+                    >,
+                > {
                     match self.map.get_mut(&unpack_type_id(*typeid)) {
                         None => None,
                         Some(h) => Some(h.values_mut().map(|x| x.as_mut())),
@@ -303,7 +331,10 @@ macro_rules! create_serde_registry_for_trait {
 
                 pub fn all_typeids(
                     &self,
-                ) -> core::iter::Map<Keys<'_, u64, HashMap<u64, Box<dyn $trait_name>>>, fn(&u64) -> TypeId> {
+                ) -> core::iter::Map<
+                    Keys<'_, u64, HashMap<u64, Box<dyn $trait_name>>>,
+                    fn(&u64) -> TypeId,
+                > {
                     self.map.keys().map(|x| pack_type_id(*x))
                 }
 
@@ -370,15 +401,13 @@ macro_rules! create_serde_registry_for_trait {
                 }
             }
 
-            impl Default for NamedSerdeAnyMap
+            impl Default for NamedSerdeAnyMap {
-            {
                 fn default() -> Self {
                     Self::new()
                 }
             }
-
         }
-        
+
         impl<'a> serde::Serialize for dyn $trait_name {
             fn serialize<S>(&self, se: S) -> Result<S::Ok, S::Error>
             where
@@ -393,7 +422,7 @@ macro_rules! create_serde_registry_for_trait {
                 seq.end()
             }
         }
-        
+
         impl<'de> serde::Deserialize<'de> for Box<dyn $trait_name> {
             fn deserialize<D>(deserializer: D) -> Result<Box<dyn $trait_name>, D::Error>
             where
@@ -402,7 +431,6 @@ macro_rules! create_serde_registry_for_trait {
                 deserializer.deserialize_seq($mod_name::BoxDynVisitor {})
             }
         }
-        
     };
 }
 

afl/src/stages/mutational.rs

@@ -56,11 +56,15 @@ where
             let testcase_maybe = state.testcase_if_interesting(input_mut, fitness)?;
             if let Some(testcase) = testcase_maybe {
                 //corpus.entries()[idx]
-                engine.events_manager_mut().fire(Event::NewTestcase {
+                engine.events_manager_mut().fire(
-                    sender_id: 0,
+                    Event::NewTestcase {
-                    testcase: testcase,
+                        sender_id: 0,
-                    phantom: PhantomData,
+                        testcase: testcase,
-                }, state, corpus)?;
+                        phantom: PhantomData,
+                    },
+                    state,
+                    corpus,
+                )?;
             }
         }
         Ok(())

afl/src/utils.rs

@@ -303,7 +303,7 @@ pub const fn next_pow2(val: u64) -> u64 {
 
 #[cfg(test)]
 mod tests {
-    use xxhash_rust::xxh3::xxh3_64_with_seed;
+    //use xxhash_rust::xxh3::xxh3_64_with_seed;
 
     use crate::utils::{next_pow2, Rand, StdRand};