add fuzz-coverage subcommand

Author: folkertdev

src/cli.rs

@@ -169,14 +169,17 @@ pub(crate) enum Subcommand {
     /// Output the environment set by cargo-llvm-cov to build Rust projects.
     ShowEnv,
 
-    /// Run tests with cargo nextest
+    /// Run tests with cargo nextest.
     Nextest {
         archive_file: bool,
     },
 
-    /// Build and archive tests with cargo nextest
+    /// Build and archive tests with cargo nextest.
     NextestArchive,
 
+    /// Generate a coverage report of a fuzz target with cargo fuzz coverage.
+    FuzzCoverage,
+
     // internal (unstable)
     Demangle,
 }
@@ -190,10 +193,21 @@ static CARGO_LLVM_COV_SHOW_ENV_USAGE: &str = include_str!("../docs/cargo-llvm-co
 static CARGO_LLVM_COV_NEXTEST_USAGE: &str = include_str!("../docs/cargo-llvm-cov-nextest.txt");
 static CARGO_LLVM_COV_NEXTEST_ARCHIVE_USAGE: &str =
     include_str!("../docs/cargo-llvm-cov-nextest-archive.txt");
+static CARGO_LLVM_COV_NEXTEST_FUZZ_COVERAGE_USAGE: &str =
+    include_str!("../docs/cargo-llvm-cov-fuzz-coverage.txt");
 
 impl Subcommand {
+    /// Whether command line flags can be forwarded to this subcommand
     fn can_passthrough(subcommand: Self) -> bool {
-        matches!(subcommand, Self::Test | Self::Run | Self::Nextest { .. } | Self::NextestArchive)
+        // These are the subcommands that themselves call other cargo subcommands.
+        matches!(
+            subcommand,
+            Self::Test
+                | Self::Run
+                | Self::Nextest { .. }
+                | Self::NextestArchive
+                | Self::FuzzCoverage
+        )
     }
 
     fn help_text(subcommand: Self) -> &'static str {
@@ -206,6 +220,7 @@ impl Subcommand {
             Self::ShowEnv => CARGO_LLVM_COV_SHOW_ENV_USAGE,
             Self::Nextest { .. } => CARGO_LLVM_COV_NEXTEST_USAGE,
             Self::NextestArchive => CARGO_LLVM_COV_NEXTEST_ARCHIVE_USAGE,
+            Self::FuzzCoverage => CARGO_LLVM_COV_NEXTEST_FUZZ_COVERAGE_USAGE,
             Self::Demangle => "", // internal API
         }
     }
@@ -220,6 +235,7 @@ impl Subcommand {
             Self::ShowEnv => "show-env",
             Self::Nextest { .. } => "nextest",
             Self::NextestArchive => "nextest-archive",
+            Self::FuzzCoverage => "fuzz-coverage",
             Self::Demangle => "demangle",
         }
     }
@@ -247,6 +263,7 @@ impl FromStr for Subcommand {
             "show-env" => Ok(Self::ShowEnv),
             "nextest" => Ok(Self::Nextest { archive_file: false }),
             "nextest-archive" => Ok(Self::NextestArchive),
+            "fuzz-coverage" => Ok(Self::FuzzCoverage),
             "demangle" => Ok(Self::Demangle),
             _ => bail!("unrecognized subcommand {s}"),
         }

src/main.rs

@@ -113,6 +113,15 @@ fn try_main() -> Result<()> {
             create_dirs(cx)?;
             archive_nextest(cx)?;
         }
+        Subcommand::FuzzCoverage => {
+            let cx = &Context::new(args)?;
+            clean::clean_partial(cx)?;
+            create_dirs(cx)?;
+            run_fuzz_coverage(cx)?;
+            if !cx.args.cov.no_report {
+                generate_report(cx)?;
+            }
+        }
         Subcommand::None | Subcommand::Test => {
             let cx = &Context::new(args)?;
             clean::clean_partial(cx)?;
@@ -439,6 +448,41 @@ fn archive_nextest(cx: &Context) -> Result<()> {
     Ok(())
 }
 
+fn run_fuzz_coverage(cx: &Context) -> Result<()> {
+    let mut cargo = cx.cargo();
+
+    set_env(cx, &mut cargo, IsNextest(false))?;
+
+    cargo.arg("fuzz").arg("coverage");
+
+    if let Some(target) = &cx.args.target {
+        cargo.arg("--target");
+        cargo.arg(target);
+    }
+    if cx.args.release {
+        cargo.arg("--release");
+    }
+
+    cargo.arg("--target-dir");
+    cargo.arg(cx.ws.target_dir.as_str());
+
+    for cargo_arg in &cx.args.cargo_args {
+        cargo.arg(cargo_arg);
+    }
+
+    if !cx.args.rest.is_empty() {
+        cargo.args(&cx.args.rest);
+    }
+
+    if term::verbose() {
+        status!("Running", "{cargo}");
+    }
+    stdout_to_stderr(cx, &mut cargo);
+    cargo.run()?;
+
+    Ok(())
+}
+
 fn run_nextest(cx: &Context) -> Result<()> {
     let mut cargo = cx.cargo();
 
@@ -533,7 +577,15 @@ fn stdout_to_stderr(cx: &Context, cargo: &mut ProcessBuilder) {
 }
 
 fn generate_report(cx: &Context) -> Result<()> {
-    merge_profraw(cx).context("failed to merge profile data")?;
+    let profraw_path = match cx.args.subcommand {
+        Subcommand::FuzzCoverage => {
+            let fuzz_target = cx.args.rest.iter().find(|s| !s.starts_with("--")).unwrap();
+            let path = std::env::current_dir()?.join(format!("coverage/{fuzz_target}/raw"));
+            Utf8PathBuf::from(path.to_string_lossy().as_ref())
+        }
+        _ => cx.ws.target_dir.clone(),
+    };
+    merge_profraw(cx, &profraw_path).context("failed to merge profile data")?;
 
     let object_files = object_files(cx).context("failed to collect object files")?;
     let ignore_filename_regex = ignore_filename_regex(cx, &object_files)?;
@@ -650,21 +702,22 @@ fn open_report(cx: &Context, path: &Utf8Path) -> Result<()> {
     Ok(())
 }
 
-fn merge_profraw(cx: &Context) -> Result<()> {
+fn merge_profraw(cx: &Context, profraw_path: &Utf8Path) -> Result<()> {
     // Convert raw profile data.
     let profraw_files = glob::glob(
-        Utf8Path::new(&glob::Pattern::escape(cx.ws.target_dir.as_str())).join("*.profraw").as_str(),
+        Utf8Path::new(&glob::Pattern::escape(profraw_path.as_str())).join("*.profraw").as_str(),
     )?
     .filter_map(Result::ok)
     .collect::<Vec<_>>();
+
     if profraw_files.is_empty() {
         if cx.ws.profdata_file.exists() {
             return Ok(());
         }
         warn!(
             "not found *.profraw files in {}; this may occur if target directory is accidentally \
              cleared, or running report subcommand without running any tests or binaries",
-            cx.ws.target_dir
+            profraw_path
         );
     }
     let mut input_files = String::new();