construct less err

Author: domenukk

crates/libafl/src/corpus/cached.rs

@@ -32,7 +32,7 @@ where
     fn cache_testcase_input<'a>(&'a self, testcase: &'a mut Testcase<I>) -> Result<(), Error> {
         let id = testcase
             .corpus_id()
-            .ok_or(Error::unknown("The testcase is not associated with an id"))?;
+            .ok_or_else(|| Error::unknown("The testcase is not associated with an id"))?;
         if testcase.input().is_none() {
             self.inner.load_input_into(testcase)?;
             let mut borrowed_num = 0;

crates/libafl/src/feedbacks/stdio.rs

@@ -43,11 +43,11 @@ impl StdOutToMetadataFeedback {
     {
         let observer = observers
             .get(&self.o_ref)
-            .ok_or(Error::illegal_state("StdOutObserver is missing"))?;
+            .ok_or_else(|| Error::illegal_state("StdOutObserver is missing"))?;
         let buffer = observer
             .output
             .as_ref()
-            .ok_or(Error::illegal_state("StdOutObserver has no stdout"))?;
+            .ok_or_else(|| Error::illegal_state("StdOutObserver has no stdout"))?;
         let stdout = String::from_utf8_lossy(buffer).into_owned();
 
         testcase
@@ -136,11 +136,11 @@ where
     ) -> Result<(), Error> {
         let observer = observers
             .get(&self.o_ref)
-            .ok_or(Error::illegal_state("StdErrObserver is missing"))?;
+            .ok_or_else(|| Error::illegal_state("StdErrObserver is missing"))?;
         let buffer = observer
             .output
             .as_ref()
-            .ok_or(Error::illegal_state("StdErrObserver has no stderr"))?;
+            .ok_or_else(|| Error::illegal_state("StdErrObserver has no stderr"))?;
         let stderr = String::from_utf8_lossy(buffer).into_owned();
 
         testcase

crates/libafl/src/schedulers/weighted.rs

@@ -238,9 +238,11 @@ where
 
     /// Cycles the strategy of the scheduler; tries to mimic AFL++'s cycling formula
     fn cycle_schedule(&mut self, metadata: &mut SchedulerMetadata) -> Result<(), Error> {
-        let mut ps = metadata.strat().ok_or(Error::illegal_argument(
-            "No strategy specified when initializing scheduler; cannot cycle!",
-        ))?;
+        let mut ps = metadata.strat().ok_or_else(|| {
+            Error::illegal_argument(
+                "No strategy specified when initializing scheduler; cannot cycle!",
+            )
+        })?;
         let new_base = match ps.base() {
             BaseSchedule::EXPLORE => BaseSchedule::EXPLOIT,
             BaseSchedule::COE => BaseSchedule::LIN,

crates/libafl_nyx/src/helper.rs

@@ -36,9 +36,10 @@ impl NyxHelper {
     where
         P: AsRef<Path>,
     {
-        let share_dir_str = share_dir.as_ref().to_str().ok_or(Error::illegal_argument(
-            "`share_dir` contains invalid UTF-8",
-        ))?;
+        let share_dir_str = share_dir
+            .as_ref()
+            .to_str()
+            .ok_or_else(|| Error::illegal_argument("`share_dir` contains invalid UTF-8"))?;
 
         let mut nyx_config = NyxConfig::load(share_dir_str).map_err(|e| {
             Error::illegal_argument(format!("Failed to load Nyx config from share dir: {e}"))

fuzzers/binary_only/intel_pt_command_executor/src/main.rs

@@ -60,7 +60,7 @@ pub fn main() -> Result<(), Box<dyn std::error::Error>> {
         executable_segments
             .into_iter()
             .next()
-            .ok_or(Error::illegal_argument(
+            .ok_or_else(||Error::illegal_argument(
                 "No executable segment found in target program",
             ))?;
     log::debug!(

fuzzers/forkserver/libafl-fuzz/src/corpus.rs

@@ -84,7 +84,7 @@ pub fn set_solution_filepath(
 fn parse_time_line(line: &str) -> Result<u64, Error> {
     line.split(": ")
         .last()
-        .ok_or(Error::illegal_state("invalid stats file"))?
+        .ok_or_else(||Error::illegal_state("invalid stats file"))?
         .parse()
         .map_err(|_| Error::illegal_state("invalid stats file"))
 }

fuzzers/forkserver/libafl-fuzz/src/env_parser.rs

@@ -137,11 +137,11 @@ fn parse_target_env(s: &str) -> Result<Option<HashMap<String, String>>, Error> {
     for vars in env_regex.captures_iter(s) {
         _ = target_env.insert(
             vars.get(1)
-                .ok_or(Error::illegal_argument("invalid AFL_TARGET_ENV format"))?
+                .ok_or_else(||Error::illegal_argument("invalid AFL_TARGET_ENV format"))?
                 .as_str()
                 .to_string(),
             vars.get(2)
-                .ok_or(Error::illegal_argument("invalid AFL_TARGET_ENV format"))?
+                .ok_or_else(||Error::illegal_argument("invalid AFL_TARGET_ENV format"))?
                 .as_str()
                 .to_string(),
         );

fuzzers/forkserver/libafl-fuzz/src/executor.rs

@@ -235,7 +235,7 @@ pub fn find_afl_binary(filename: &str, same_dir_as: Option<PathBuf>) -> Result<P
     if !is_library {
         // finally, check the path for the binary
         return find_executable_in_path(&filename)
-            .ok_or(Error::unknown(format!("cannot find {filename}")));
+            .ok_or_else(||Error::unknown(format!("cannot find {filename}")));
     }
 
     Err(Error::unknown(format!("cannot find {filename}")))

fuzzers/forkserver/libafl-fuzz/src/fuzzer.rs

@@ -392,12 +392,12 @@ define_run_client!(state, mgr, fuzzer_dir, core_id, opt, is_main_node, {
         state.walk_initial_inputs(std::slice::from_ref(&opt.input_dir), |path: &PathBuf| {
             let mut filename = path
                 .file_name()
-                .ok_or(Error::illegal_state(format!(
+                .ok_or_else(||Error::illegal_state(format!(
                     "file {} in input directory does not have a filename",
                     path.display()
                 )))?
                 .to_str()
-                .ok_or(Error::illegal_state(format!(
+                .ok_or_else(||Error::illegal_state(format!(
                     "file {} in input directory does not have a legal filename",
                     path.display()
                 )))?