feat(warnings) add build.warnings option

Author: arlosi

src/cargo/core/compiler/job_queue/mod.rs

@@ -140,6 +140,7 @@ use crate::core::compiler::future_incompat::{
 };
 use crate::core::resolver::ResolveBehavior;
 use crate::core::{PackageId, Shell, TargetKind};
+use crate::util::context::WarningHandling;
 use crate::util::diagnostic_server::{self, DiagnosticPrinter};
 use crate::util::errors::AlreadyPrintedError;
 use crate::util::machine_message::{self, Message as _};
@@ -601,6 +602,7 @@ impl<'gctx> DrainState<'gctx> {
         plan: &mut BuildPlan,
         event: Message,
     ) -> Result<(), ErrorToHandle> {
+        let warning_handling = build_runner.bcx.gctx.warning_handling()?;
         match event {
             Message::Run(id, cmd) => {
                 build_runner
@@ -638,7 +640,9 @@ impl<'gctx> DrainState<'gctx> {
                 }
             }
             Message::Warning { id, warning } => {
-                build_runner.bcx.gctx.shell().warn(warning)?;
+                if warning_handling != WarningHandling::Allow {
+                    build_runner.bcx.gctx.shell().warn(warning)?;
+                }
                 self.bump_warning_count(id, true, false);
             }
             Message::WarningCount {
@@ -652,13 +656,14 @@ impl<'gctx> DrainState<'gctx> {
                 self.print.print(&msg)?;
             }
             Message::Finish(id, artifact, result) => {
+                let mut warning_count = 0;
                 let unit = match artifact {
                     // If `id` has completely finished we remove it
                     // from the `active` map ...
                     Artifact::All => {
                         trace!("end: {:?}", id);
                         self.finished += 1;
-                        self.report_warning_count(
+                        warning_count = self.report_warning_count(
                             build_runner.bcx.gctx,
                             id,
                             &build_runner.bcx.rustc().workspace_wrapper,
@@ -693,6 +698,12 @@ impl<'gctx> DrainState<'gctx> {
                         });
                     }
                 }
+                if let Err(error) = warning_handling.error_for_warnings(warning_count) {
+                    return Err(ErrorToHandle {
+                        error,
+                        print_always: true,
+                    });
+                }
             }
             Message::FutureIncompatReport(id, items) => {
                 let package_id = self.active[&id].pkg.package_id();
@@ -963,32 +974,32 @@ impl<'gctx> DrainState<'gctx> {
     }
 
     fn emit_warnings(
-        &mut self,
+        &self,
         msg: Option<&str>,
         unit: &Unit,
-        build_runner: &mut BuildRunner<'_, '_>,
+        build_runner: &BuildRunner<'_, '_>,
     ) -> CargoResult<()> {
         let outputs = build_runner.build_script_outputs.lock().unwrap();
         let Some(metadata) = build_runner.find_build_script_metadata(unit) else {
             return Ok(());
         };
-        let bcx = &mut build_runner.bcx;
+        let gctx = build_runner.bcx.gctx;
         if let Some(output) = outputs.get(metadata) {
             if !output.warnings.is_empty() {
                 if let Some(msg) = msg {
-                    writeln!(bcx.gctx.shell().err(), "{}\n", msg)?;
+                    writeln!(gctx.shell().err(), "{}\n", msg)?;
                 }
 
                 for warning in output.warnings.iter() {
                     let warning_with_package =
                         format!("{}@{}: {}", unit.pkg.name(), unit.pkg.version(), warning);
 
-                    bcx.gctx.shell().warn(warning_with_package)?;
+                    gctx.shell().warn(warning_with_package)?;
                 }
 
                 if msg.is_some() {
                     // Output an empty line.
-                    writeln!(bcx.gctx.shell().err())?;
+                    writeln!(gctx.shell().err())?;
                 }
             }
         }
@@ -1022,13 +1033,13 @@ impl<'gctx> DrainState<'gctx> {
         gctx: &GlobalContext,
         id: JobId,
         rustc_workspace_wrapper: &Option<PathBuf>,
-    ) {
+    ) -> usize {
         let count = match self.warning_count.remove(&id) {
             // An error could add an entry for a `Unit`
             // with 0 warnings but having fixable
             // warnings be disallowed
             Some(count) if count.total > 0 => count,
-            None | Some(_) => return,
+            None | Some(_) => return 0,
         };
         let unit = &self.active[&id];
         let mut message = descriptive_pkg_name(&unit.pkg.name(), &unit.target, &unit.mode);
@@ -1089,6 +1100,7 @@ impl<'gctx> DrainState<'gctx> {
         // Errors are ignored here because it is tricky to handle them
         // correctly, and they aren't important.
         let _ = gctx.shell().warn(message);
+        count.total
     }
 
     fn finish(

src/cargo/core/compiler/mod.rs

@@ -90,6 +90,7 @@ pub use crate::core::compiler::unit::{Unit, UnitInterner};
 use crate::core::manifest::TargetSourcePath;
 use crate::core::profiles::{PanicStrategy, Profile, StripInner};
 use crate::core::{Feature, PackageId, Target, Verbosity};
+use crate::util::context::WarningHandling;
 use crate::util::errors::{CargoResult, VerboseError};
 use crate::util::interning::InternedString;
 use crate::util::machine_message::{self, Message};
@@ -200,13 +201,16 @@ fn compile<'gctx>(
         } else {
             // We always replay the output cache,
             // since it might contain future-incompat-report messages
+            let show_diagnostics = unit.show_warnings(bcx.gctx)
+                && build_runner.bcx.gctx.warning_handling().unwrap_or_default()
+                    != WarningHandling::Allow;
             let work = replay_output_cache(
                 unit.pkg.package_id(),
                 PathBuf::from(unit.pkg.manifest_path()),
                 &unit.target,
                 build_runner.files().message_cache_path(unit),
                 build_runner.bcx.build_config.message_format,
-                unit.show_warnings(bcx.gctx),
+                show_diagnostics,
             );
             // Need to link targets on both the dirty and fresh.
             work.then(link_targets(build_runner, unit, true)?)
@@ -1621,10 +1625,12 @@ impl OutputOptions {
         // Remove old cache, ignore ENOENT, which is the common case.
         drop(fs::remove_file(&path));
         let cache_cell = Some((path, LazyCell::new()));
+        let show_diagnostics =
+            build_runner.bcx.gctx.warning_handling().unwrap_or_default() != WarningHandling::Allow;
         OutputOptions {
             format: build_runner.bcx.build_config.message_format,
             cache_cell,
-            show_diagnostics: true,
+            show_diagnostics,
             warnings_seen: 0,
             errors_seen: 0,
         }

src/cargo/core/features.rs

@@ -787,6 +787,7 @@ unstable_cli_options!(
     target_applies_to_host: bool = ("Enable the `target-applies-to-host` key in the .cargo/config.toml file"),
     trim_paths: bool = ("Enable the `trim-paths` option in profiles"),
     unstable_options: bool = ("Allow the usage of unstable options"),
+    warnings: bool = ("Allow use of the build.warnings config key"),
 );
 
 const STABILIZED_COMPILE_PROGRESS: &str = "The progress bar is now always \
@@ -1290,6 +1291,7 @@ impl CliUnstable {
             "script" => self.script = parse_empty(k, v)?,
             "target-applies-to-host" => self.target_applies_to_host = parse_empty(k, v)?,
             "unstable-options" => self.unstable_options = parse_empty(k, v)?,
+            "warnings" => self.warnings = parse_empty(k, v)?,
             _ => bail!("\
             unknown `-Z` flag specified: {k}\n\n\
             For available unstable features, see https://doc.rust-lang.org/nightly/cargo/reference/unstable.html\n\

src/cargo/util/context/mod.rs

@@ -2004,6 +2004,15 @@ impl GlobalContext {
         })?;
         Ok(deferred.borrow_mut())
     }
+
+    /// Get the global [`WarningHandling`] configuration.
+    pub fn warning_handling(&self) -> CargoResult<WarningHandling> {
+        if self.unstable_flags.warnings {
+            Ok(self.build_config()?.warnings.unwrap_or_default())
+        } else {
+            Ok(Default::default())
+        }
+    }
 }
 
 /// Internal error for serde errors.
@@ -2615,6 +2624,32 @@ pub struct CargoBuildConfig {
     // deprecated alias for artifact-dir
     pub out_dir: Option<ConfigRelativePath>,
     pub artifact_dir: Option<ConfigRelativePath>,
+    pub warnings: Option<WarningHandling>,
+}
+
+/// Whether warnings should warn, be allowed, or cause an error.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum WarningHandling {
+    #[default]
+    /// Output warnings.
+    Warn,
+    /// Allow warnings (do not output them).
+    Allow,
+    /// Error if  warnings are emitted.
+    Deny,
+}
+
+impl WarningHandling {
+    pub fn error_for_warnings(self, warning_count: usize) -> CargoResult<()> {
+        if self == WarningHandling::Deny && warning_count > 0 {
+            Err(anyhow::anyhow!(
+                "warnings are denied by `build.warnings` configuration"
+            ))
+        } else {
+            Ok(())
+        }
+    }
 }
 
 /// Configuration for `build.target`.

src/doc/src/reference/unstable.md

@@ -114,6 +114,7 @@ Each new feature described below should explain how to use it.
 * Other
     * [gitoxide](#gitoxide) --- Use `gitoxide` instead of `git2` for a set of operations.
     * [script](#script) --- Enable support for single-file `.rs` packages.
+    * [warnings](#warnings) --- controls warning behavior; allows for erroring or ignoring warnings.
 
 ## allow-features
 
@@ -1816,3 +1817,22 @@ default behavior.
 
 See the [build script documentation](build-scripts.md#rustc-check-cfg) for information
 about specifying custom cfgs.
+
+## warnings
+
+The `-Z warnings` feature enables the `build.warnings` configuration option to control how
+Cargo handles warnings. If the `-Z warnings` unstable flag is not enabled, then
+the `build.warnings` config will be ignored.
+
+### `build.warnings`
+* Type: string
+* Default: `warn`
+* Environment: `CARGO_BUILD_WARNINGS`
+
+Controls how Cargo handles warnings. Allowed values are:
+* `warn`: warnings are emitted as warnings (default).
+* `allow`: warnings are hidden.
+* `deny`: if warnings are emitted, an error will be raised at the end of the operation and the process will exit with a failure exit code. 
+
+This setting currently only applies to rustc warnings. It may apply to additional warnings (such as Cargo lints or Cargo warnings)
+in the future.

tests/testsuite/cargo/z_help/stdout.term.svg

@@ -179,6 +179,7 @@ mod vendor;
 mod verify_project;
 mod version;
 mod warn_on_failure;
+mod warning_override;
 mod weak_dep_features;
 mod workspaces;
 mod yank;