clippy

src/actions.rs

@@ -53,7 +53,8 @@ pub enum Action {
 impl Action {
     /// returns `true` if the action is [`Action::Discard`] or has a flow control
     /// directive of [`FlowControl::Discard`]; false otherwise
-    pub fn should_discard(&self) -> bool {
+    #[must_use]
+    pub const fn should_discard(&self) -> bool {
         matches!(self, Self::Discard)
             || matches!(self, Action::AddToCorpus(_, _, FlowControl::Discard))
     }

src/corpora/directory.rs

@@ -113,12 +113,11 @@ where
                     continue;
                 }
 
-                if let Ok(associated_type) = line.parse() {
-                    // since the associated type `Item` must implement FromStr
-                    // we can call .parse() to convert it into the expected
-                    // type before pushing it onto the container
-                    items.push(associated_type);
-                }
+                // since the associated type `Item` must implement FromStr
+                // we can call .parse() to convert it into the expected
+                // type before pushing it onto the container. unwrap is safe here
+                let associated_type = line.parse().unwrap();
+                items.push(associated_type);
             }
         }
     }

src/corpora/wordlist.rs

@@ -294,12 +294,11 @@ impl Wordlist {
                 continue;
             }
 
-            if let Ok(associated_type) = line.parse() {
-                // since the associated type `Item` must implement FromStr
-                // we can call .parse() to convert it into the expected
-                // type before pushing it onto the container of type T
-                items.push(associated_type);
-            }
+            // since the associated type `Item` must implement FromStr
+            // we can call .parse() to convert it into the expected
+            // type before pushing it onto the container. unwrap is safe here
+            let associated_type = line.parse().unwrap();
+            items.push(associated_type);
         }
 
         Ok(WordlistBuilder {

src/events/mod.rs

@@ -157,7 +157,9 @@ pub struct FuzzNTimes {
 }
 
 /// This event is emitted when a fuzzer enters its fuzzing loop via the
-/// [`Fuzzer::fuzz_once`] method. If the fuzzer was started with [`Fuzzer::fuzz_n_iterations`]
+/// [`Fuzzer::fuzz_once`] method.
+///
+/// If the fuzzer was started with [`Fuzzer::fuzz_n_iterations`]
 /// or [`Fuzzer::fuzz`], this event will be emitted once per iteration.
 ///
 /// [`Fuzzer::fuzz_once`]: crate::fuzzers::AsyncFuzzing::fuzz_once
@@ -187,9 +189,11 @@ pub struct FuzzOnce {
     pub corpora_length: usize,
 }
 
-/// This event is emitted when a fuzzer exits the fuzzing loop. This can happen
-/// when the fuzzer has iterated over the entire corpus for the specified number
-/// of times, or when the fuzzer exits early due to an [`Action::StopFuzzing`]
+/// This event is emitted when a fuzzer exits the fuzzing loop.
+///
+/// This can happen when the fuzzer has iterated over the entire
+/// corpus for the specified number of times, or when the fuzzer
+/// exits early due to an [`Action::StopFuzzing`]
 ///
 /// [`Action::StopFuzzing`]: crate::actions::Action::StopFuzzing
 #[derive(Copy, Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

src/processors/mod.rs

@@ -37,8 +37,10 @@ pub enum Ordering {
 }
 
 /// marker trait; post-processors are used to perform actions after observations
-/// are made and actions are taken. They can be thought of a 'final action' that
-/// the fuzzer should perform, i.e. logging/printing etc...
+/// are made and actions are taken.
+///
+/// They can be thought of a 'final action' that the fuzzer should perform,
+/// i.e. logging/printing etc...
 pub trait Processor: DynClone + AsAny + Named {}
 
 /// defines the hooks that are executed for the purpose of processing

src/processors/request.rs

@@ -13,10 +13,11 @@ use crate::{actions::Action, responses::Response};
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
 
-/// a `RequestProcessor` provides access to the fuzzer's mutated [`Request`] that
-/// is about to be sent to the target, as well as the [`Action`] returned
-/// from calling the analogous hook on [`Deciders`]. Those two objects may
-/// be used to produce side-effects, such as printing, logging, etc...
+/// a `RequestProcessor` provides access to the fuzzer's mutated [`Request`]
+/// and the [`Action`] returned from calling the analogous hook on [`Deciders`].
+///
+/// Those two objects may be used to produce side-effects, such as printing,
+/// logging, etc...
 ///
 /// [`Deciders`]: crate::deciders::Deciders
 ///

src/processors/response.rs

@@ -16,6 +16,7 @@ use tracing::instrument;
 
 /// a `ResponseProcessor` provides access to the fuzzer's instance of [`ResponseObserver`]
 /// as well as the [`Action`] returned from calling the analogous hook on [`Deciders`].
+///
 /// Those two objects may be used to produce side-effects, such as printing, logging,
 /// etc...
 ///

src/processors/statistics.rs

@@ -19,6 +19,7 @@ use std::sync::{Arc, RwLock};
 
 /// a `StatisticsProcessor` provides access to the fuzzer's instance of [`Statistics`]
 /// as well as the [`Action`] returned from calling the analogous hook on [`Deciders`].
+///
 /// Those two objects may be used to produce side-effects, such as printing, logging,
 /// etc...
 ///

src/requests/mod.rs

@@ -1,7 +1,8 @@
 //! provides the core [`Request`] type and the [`ShouldFuzz`] directives that dictate
-//! what parts of a `Request` should be mutated. Additionally, a
-//! [URL Encoder](./requests/encoders/enum.Encoder.html) is provided by default, while other
-//! encoders are available on an opt-in basis via feature flags
+//! what parts of a `Request` should be mutated.
+//!
+//! Additionally, a [URL Encoder](./requests/encoders/enum.Encoder.html) is provided
+//! by default, while other encoders are available on an opt-in basis via feature flags
 mod directives;
 mod encoders;
 mod request;