feat: Add -Zdetect-antivirus=always for disabling heuristics

Author: madsmtm

src/cargo/core/compiler/build_config.rs

@@ -1,4 +1,5 @@
 use crate::core::compiler::CompileKind;
+use crate::core::features::DetectAntivirus;
 use crate::util::context::JobsConfig;
 use crate::util::interning::InternedString;
 use crate::util::{CargoResult, GlobalContext, RustfixDiagnosticServer};
@@ -54,7 +55,7 @@ pub struct BuildConfig {
     pub compile_time_deps_only: bool,
     /// Whether we should try to detect and notify the user when antivirus
     /// software might make newly created binaries slow to launch.
-    pub detect_antivirus: bool,
+    pub detect_antivirus: DetectAntivirus,
 }
 
 fn default_parallelism() -> CargoResult<u32> {
@@ -131,16 +132,16 @@ impl BuildConfig {
         };
 
         let detect_antivirus = match (cfg.detect_antivirus, gctx.cli_unstable().detect_antivirus) {
-            // Enabled by default (for now only when the flag is set).
-            (None, unstable_flag) => unstable_flag,
-            // But allow overriding with configuration option.
-            (Some(cfg_option), true) => cfg_option,
-            (Some(_), false) => {
+            // Warn while the config is still unstable.
+            (Some(_), DetectAntivirus::Never) => {
                 gctx.shell().warn(
                     "ignoring 'build.detect-antivirus' config, pass `-Zdetect-antivirus` to enable it",
                 )?;
-                false
+                DetectAntivirus::Never
             }
+            // Allow overriding with config.
+            (Some(false), _) => DetectAntivirus::Never,
+            (_, flag) => flag,
         };
 
         Ok(BuildConfig {

src/cargo/core/features.rs

@@ -400,6 +400,36 @@ impl FromStr for FixEdition {
     }
 }
 
+/// The value for `-Zdetect-antivirus`.
+#[derive(Debug, Deserialize, Default, PartialEq, Eq, Hash, Copy, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum DetectAntivirus {
+    /// Always detect antivirus.
+    ///
+    /// This is useful when testing the feature, but isn't expected to be
+    /// useful to the general user.
+    Always,
+    /// Detect antivirus, but only when deemed reasonable.
+    ///
+    /// This is intended to be the default in the future.
+    Auto,
+    /// Never attempt to detect antivirus.
+    #[default]
+    Never,
+}
+
+impl FromStr for DetectAntivirus {
+    type Err = anyhow::Error;
+    fn from_str(s: &str) -> Result<Self, <Self as FromStr>::Err> {
+        Ok(match s {
+            "always" => Self::Always,
+            "auto" => Self::Auto,
+            "never" => Self::Never,
+            _ => bail!("invalid `-Zdetect-antivirus`, expected `always`, `auto` or `never`, got `{s}`"),
+        })
+    }
+}
+
 #[derive(Debug, PartialEq)]
 enum Status {
     Stable,
@@ -854,7 +884,7 @@ unstable_cli_options!(
     checksum_freshness: bool = ("Use a checksum to determine if output is fresh rather than filesystem mtime"),
     codegen_backend: bool = ("Enable the `codegen-backend` option in profiles in .cargo/config.toml file"),
     config_include: bool = ("Enable the `include` key in config files"),
-    detect_antivirus: bool = ("Enable the experimental antivirus detection and the config option to disable it"),
+    detect_antivirus: DetectAntivirus = ("Enable the experimental antivirus detection and the config option to disable it"),
     direct_minimal_versions: bool = ("Resolve minimal dependency versions instead of maximum (direct dependencies only)"),
     dual_proc_macros: bool = ("Build proc-macros for both the host and the target"),
     feature_unification: bool = ("Enable new feature unification modes in workspaces"),
@@ -1374,7 +1404,7 @@ impl CliUnstable {
             "codegen-backend" => self.codegen_backend = parse_empty(k, v)?,
             "config-include" => self.config_include = parse_empty(k, v)?,
             "direct-minimal-versions" => self.direct_minimal_versions = parse_empty(k, v)?,
-            "detect-antivirus" => self.detect_antivirus = parse_empty(k, v)?,
+            "detect-antivirus" => self.detect_antivirus = v.unwrap_or("auto").parse()?,
             "dual-proc-macros" => self.dual_proc_macros = parse_empty(k, v)?,
             "feature-unification" => self.feature_unification = parse_empty(k, v)?,
             "fix-edition" => {

src/cargo/ops/cargo_compile/mod.rs

@@ -46,6 +46,7 @@ use crate::core::compiler::{BuildConfig, BuildContext, BuildRunner, Compilation}
 use crate::core::compiler::{CompileKind, CompileMode, CompileTarget, RustcTargetData, Unit};
 use crate::core::compiler::{CrateType, TargetInfo, apply_env_config, standard_lib};
 use crate::core::compiler::{DefaultExecutor, Executor, UnitInterner};
+use crate::core::features::DetectAntivirus;
 use crate::core::profiles::Profiles;
 use crate::core::resolver::features::{self, CliFeatures, FeaturesFor};
 use crate::core::resolver::{HasDevUnits, Resolve};
@@ -560,7 +561,7 @@ where `<compatible-ver>` is the latest version supporting rustc {rustc_version}"
         }
     }
 
-    if build_config.detect_antivirus {
+    if build_config.detect_antivirus != DetectAntivirus::Never {
         // Count the number of test binaries and build scripts we'll need to
         // run. This doesn't take into account the binary that will be run
         // if `cargo run` was specified, and doesn't handle pre-2024 `rustdoc`
@@ -588,7 +589,9 @@ where `<compatible-ver>` is the latest version supporting rustc {rustc_version}"
         // We also don't want to do this check when installing, since there
         // might be `cargo install` users who are not necessarily developers
         // (and so the note will be irrelevant to them).
-        if 10 < num_binaries && build_config.intent != UserIntent::Install {
+        if (10 < num_binaries && build_config.intent != UserIntent::Install)
+            || build_config.detect_antivirus == DetectAntivirus::Always
+        {
             if let Err(err) = detect_antivirus::detect_and_report(gctx) {
                 // Errors in this detection are not fatal.
                 tracing::error!("failed detecting whether binaries may be slow to run: {err}");

src/doc/src/reference/unstable.md

@@ -1952,7 +1952,9 @@ This layout change unblocks work towards caching and locking improvements.
 
 * Tracking Issue: [#0](https://github.com/rust-lang/cargo/issues/0)
 
-The `-Zdetect-antivirus` flag enables detection of antivirus software that might make launching a binary for the first time slower (which in turn makes Cargo's build scripts and tests slower), and outputs a notice to the user if this is the case.
+The `-Zdetect-antivirus=auto` flag enables detection of antivirus software that might make launching a binary for the first time slower (which in turn makes Cargo's build scripts and tests slower), and outputs a notice to the user if this is the case.
+
+This feature uses a small heuristic to avoid doing the detection when deemed unnecessary. `-Zdetect-antivirus=always` may be used to disable this heuristic.
 
 This feature will be enabled by default in the future (the flag acts as-if this future is now).