Add option to error when warnings are emitted, or ignore warnings

src/bin/cargo/cli.rs

@@ -1,6 +1,7 @@
 use anyhow::{anyhow, Context as _};
 use cargo::core::shell::Shell;
 use cargo::core::{features, CliUnstable};
+use cargo::util::config::WarningHandling;
 use cargo::{self, drop_print, drop_println, CargoResult, CliResult, Config};
 use clap::{builder::UnknownArgumentValueParser, Arg, ArgMatches};
 use itertools::Itertools;
@@ -181,7 +182,9 @@ Run with 'cargo -Z [FLAG] [COMMAND]'",
     config_configure(config, &expanded_args, subcommand_args, global_args, &exec)?;
     super::init_git(config);
 
-    exec.exec(config, subcommand_args)
+    let result = exec.exec(config, subcommand_args);
+    config.shell().error_for_warnings()?;
+    result
 }
 
 pub fn get_version_string(is_verbose: bool) -> String {
@@ -394,6 +397,13 @@ fn config_configure(
     let frozen = args.flag("frozen") || global_args.frozen;
     let locked = args.flag("locked") || global_args.locked;
     let offline = args.flag("offline") || global_args.offline;
+    let warnings = match args.get_one::<String>("warnings").map(String::as_str) {
+        Some("ignore") => Some(WarningHandling::Ignore),
+        Some("warn") => Some(WarningHandling::Warn),
+        Some("error") => Some(WarningHandling::Error),
+        None => None,
+        _ => unreachable!(),
+    };
     let mut unstable_flags = global_args.unstable_flags;
     if let Some(values) = args.get_many::<String>("unstable-features") {
         unstable_flags.extend(values.cloned());
@@ -405,6 +415,7 @@ fn config_configure(
     config.configure(
         verbose,
         quiet,
+        warnings,
         color,
         frozen,
         locked,
@@ -595,6 +606,11 @@ See '<cyan,bold>cargo help</> <cyan><<command>></>' for more information on a sp
                 .value_name("WHEN")
                 .global(true),
         )
+        .arg(
+            opt("warnings", "Warning behavior")
+                .value_parser(["error", "warn", "ignore"])
+                .global(true),
+        )
         .arg(
             Arg::new("directory")
                 .help("Change to DIRECTORY before doing anything (nightly-only)")

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::config::WarningHandling;
 use crate::util::diagnostic_server::{self, DiagnosticPrinter};
 use crate::util::errors::AlreadyPrintedError;
 use crate::util::machine_message::{self, Message as _};
@@ -314,8 +315,10 @@ impl<'cfg> DiagDedupe<'cfg> {
             return Ok(false);
         }
         let mut shell = self.config.shell();
-        shell.print_ansi_stderr(diag.as_bytes())?;
-        shell.err().write_all(b"\n")?;
+        if shell.warnings() != WarningHandling::Ignore {
+            shell.print_ansi_stderr(diag.as_bytes())?;
+            shell.err().write_all(b"\n")?;
+        }
         Ok(true)
     }
 }

src/cargo/core/shell.rs

@@ -5,6 +5,7 @@ use std::io::IsTerminal;
 use anstream::AutoStream;
 use anstyle::Style;
 
+use crate::util::config::WarningHandling;
 use crate::util::errors::CargoResult;
 use crate::util::style::*;
 
@@ -57,6 +58,10 @@ pub struct Shell {
     /// Flag that indicates the current line needs to be cleared before
     /// printing. Used when a progress bar is currently displayed.
     needs_clear: bool,
+    /// How warning should be handled.
+    warnings: WarningHandling,
+    /// The number of warnings so far.
+    warning_count: usize,
 }
 
 impl fmt::Debug for Shell {
@@ -115,6 +120,8 @@ impl Shell {
             },
             verbosity: Verbosity::Verbose,
             needs_clear: false,
+            warnings: WarningHandling::Warn,
+            warning_count: 0,
         }
     }
 
@@ -124,6 +131,8 @@ impl Shell {
             output: ShellOut::Write(AutoStream::never(out)), // strip all formatting on write
             verbosity: Verbosity::Verbose,
             needs_clear: false,
+            warnings: WarningHandling::Warn,
+            warning_count: 0,
         }
     }
 
@@ -263,10 +272,13 @@ impl Shell {
 
     /// Prints an amber 'warning' message.
     pub fn warn<T: fmt::Display>(&mut self, message: T) -> CargoResult<()> {
-        match self.verbosity {
-            Verbosity::Quiet => Ok(()),
-            _ => self.print(&"warning", Some(&message), &WARN, false),
+        self.warning_count += 1;
+        if matches!(self.verbosity, Verbosity::Quiet)
+            || matches!(self.warnings, WarningHandling::Ignore)
+        {
+            return Ok(());
         }
+        self.print(&"warning", Some(&message), &WARN, false)
     }
 
     /// Prints a cyan 'note' message.
@@ -284,6 +296,31 @@ impl Shell {
         self.verbosity
     }
 
+    /// Updates how warnings are handled.
+    pub fn set_warnings(&mut self, warnings: WarningHandling) {
+        self.warnings = warnings;
+    }
+
+    /// Gets the warning handling behavior.
+    pub fn warnings(&self) -> WarningHandling {
+        self.warnings
+    }
+
+    /// Emit an error if any warnings have been seen.
+    pub fn error_for_warnings(&self) -> CargoResult<()> {
+        if self.warning_count > 0 && self.warnings == WarningHandling::Error {
+            let quiet_note = if self.verbosity == Verbosity::Quiet {
+                " (note that verbosity is set to quiet, which may hide warnings)"
+            } else {
+                ""
+            };
+            anyhow::bail!(
+                "warnings detected and warnings are disallowed by configuration{quiet_note}"
+            );
+        }
+        Ok(())
+    }
+
     /// Updates the color choice (always, never, or auto) from a string..
     pub fn set_color_choice(&mut self, color: Option<&str>) -> CargoResult<()> {
         if let ShellOut::Stream {

src/cargo/util/config/mod.rs

@@ -158,6 +158,16 @@ pub struct CredentialCacheValue {
     pub operation_independent: bool,
 }
 
+/// Whether warnings should warn, be ignored, or cause an error.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserialize, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum WarningHandling {
+    #[default]
+    Warn,
+    Ignore,
+    Error,
+}
+
 /// Configuration information for cargo. This is not specific to a build, it is information
 /// relating to cargo itself.
 #[derive(Debug)]
@@ -971,6 +981,7 @@ impl Config {
         &mut self,
         verbose: u32,
         quiet: bool,
+        warnings: Option<WarningHandling>,
         color: Option<&str>,
         frozen: bool,
         locked: bool,
@@ -1032,6 +1043,8 @@ impl Config {
 
         self.shell().set_verbosity(verbosity);
         self.shell().set_color_choice(color)?;
+        self.shell()
+            .set_warnings(warnings.or_else(|| term.warnings).unwrap_or_default());
         self.progress_config = term.progress.unwrap_or_default();
         self.extra_verbose = extra_verbose;
         self.frozen = frozen;
@@ -2563,6 +2576,7 @@ struct TermConfig {
     #[serde(default)]
     #[serde(deserialize_with = "progress_or_string")]
     progress: Option<ProgressConfig>,
+    warnings: Option<WarningHandling>,
 }
 
 #[derive(Debug, Default, Deserialize)]

src/doc/man/includes/options-display.md

@@ -22,3 +22,14 @@ Control when colored output is used. Valid values:
 May also be specified with the `term.color`
 [config value](../reference/config.html).
 {{/option}}
+
+{{#option "`--warnings`"}}
+Overrides how warnings are handled. Valid values:
+
+* `warn` (default): warnings are displayed and do not fail the operation.
+* `error`: if any warnings are encountered an error will be emitted at the of the operation.
+* `ignore`: warnings will be silently ignored.
+
+May also be specified with the `term.warnings`
+[config value](../reference/config.html).
+{{/option}}

src/doc/src/reference/config.md

@@ -1257,6 +1257,19 @@ Controls whether or not extra detailed messages are displayed by Cargo.
 Specifying the `--quiet` flag will override and disable verbose output.
 Specifying the `--verbose` flag will override and force verbose output.
 
+#### `term.warnings`
+* Type: string
+* Default: "warn"
+* Environment: `CARGO_TERM_WARNINGS`
+
+Overrides how warnings are handled, including warnings that come from `rustc`.
+
+The `--warnings=` CLI option overrides this configuration value.
+
+* `warn` (default): warnings are displayed and do not fail the operation.
+* `error`: if any warnings are encountered an error will be emitted at the of the operation.
+* `ignore`: warnings will be silently ignored.
+
 #### `term.color`
 * Type: string
 * Default: "auto"

tests/testsuite/config.rs

@@ -107,6 +107,7 @@ impl ConfigBuilder {
             0,
             false,
             None,
+            None,
             false,
             false,
             false,

tests/testsuite/main.rs

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

tests/testsuite/warning_override.rs

@@ -0,0 +1,85 @@
+//! Tests for overriding warning behavior using `--warnings=` on the CLI or `term.warnings` config option.
+
+use cargo_test_support::{project, Project};
+
+const WARNING1: &'static str = "[WARNING] unused variable: `x`";
+const WARNING2: &'static str = "[WARNING] unused config key `build.xyz` in `[..]`";
+
+fn make_project(main_src: &str) -> Project {
+    project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "foo"
+                version = "0.0.1"
+                authors = []
+            "#,
+        )
+        .file("src/main.rs", &format!("fn main() {{ {} }}", main_src))
+        .build()
+}
+
+#[cargo_test]
+fn rustc_warnings() {
+    let p = make_project("let x = 3;");
+    p.cargo("check --warnings=warn")
+        .with_stderr_contains(WARNING1)
+        .run();
+
+    p.cargo("check --warnings=error")
+        .with_stderr_contains(WARNING1)
+        .with_stderr_contains(
+            "[ERROR] warnings detected and warnings are disallowed by configuration",
+        )
+        .with_status(101)
+        .run();
+
+    p.cargo("check --warnings=ignore")
+        .with_stderr_does_not_contain(WARNING1)
+        .run();
+}
+
+#[cargo_test]
+fn config() {
+    let p = make_project("let x = 3;");
+    p.cargo("check")
+        .env("CARGO_TERM_WARNINGS", "error")
+        .with_stderr_contains(WARNING1)
+        .with_stderr_contains(
+            "[ERROR] warnings detected and warnings are disallowed by configuration",
+        )
+        .with_status(101)
+        .run();
+
+    // CLI has precedence over config
+    p.cargo("check --warnings=ignore")
+        .env("CARGO_TERM_WARNINGS", "error")
+        .with_stderr_does_not_contain(WARNING1)
+        .run();
+
+    p.cargo("check")
+        .env("CARGO_TERM_WARNINGS", "ignore")
+        .with_stderr_does_not_contain(WARNING1)
+        .run();
+}
+
+#[cargo_test]
+/// Warnings that come from cargo rather than rustc
+fn cargo_warnings() {
+    let p = make_project("");
+    p.change_file(".cargo/config.toml", "[build]\nxyz = false");
+    p.cargo("check").with_stderr_contains(WARNING2).run();
+
+    p.cargo("check --warnings=error")
+        .with_stderr_contains(WARNING2)
+        .with_stderr_contains(
+            "[ERROR] warnings detected and warnings are disallowed by configuration",
+        )
+        .with_status(101)
+        .run();
+
+    p.cargo("check --warnings=ignore")
+        .with_stderr_does_not_contain(WARNING2)
+        .run();
+}