rename to DenyLevel and integrate Config.deny_warnings

Author: 0xrusowsky

crates/config/src/lint.rs

@@ -26,8 +26,8 @@ pub struct LinterConfig {
     /// Defaults to true. Set to false to disable automatic linting during builds.
     pub lint_on_build: bool,
 
-    /// Set the failure threshold.
-    pub fail_on: FailOn,
+    /// Set the minimum level threshold for diagnostics.
+    pub deny: DenyLevel,
 
     /// Configurable patterns that should be excluded when performing `mixedCase` lint checks.
     ///
@@ -42,23 +42,23 @@ impl Default for LinterConfig {
             severity: Vec::new(),
             exclude_lints: Vec::new(),
             ignore: Vec::new(),
-            fail_on: FailOn::Never,
+            deny: DenyLevel::Never,
             mixed_case_exceptions: vec!["ERC".to_string()],
         }
     }
 }
 
 /// Diagnostic level (minimum) at which the process should finish with a non-zero exit.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default, Serialize, Deserialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum FailOn {
+#[serde(rename_all = "lowercase")]
+pub enum DenyLevel {
     /// Always exit with zero code.
     #[default]
     Never,
     /// Exit with a non-zero code if any warnings are found.
-    Warning,
+    Warnings,
     /// Exit with a non-zero code if any notes or warnings are found.
-    Note,
+    Notes,
 }
 
 /// Severity of a lint.

crates/forge/src/cmd/build.rs

@@ -21,6 +21,7 @@ use foundry_config::{
         value::{Dict, Map, Value},
     },
     filter::expand_globs,
+    lint::DenyLevel,
 };
 use serde::Serialize;
 use std::path::PathBuf;
@@ -176,7 +177,11 @@ impl BuildArgs {
                     let _ = compiler.lower_asts();
                     Ok(())
                 })?;
-                linter.lint(&input_files, config.lint.fail_on, &mut compiler)?;
+                linter.lint(
+                    &input_files,
+                    if config.deny_warnings { DenyLevel::Warnings } else { config.lint.deny },
+                    &mut compiler,
+                )?;
             }
         }
 

crates/forge/src/cmd/geiger.rs

@@ -1,7 +1,7 @@
 use clap::{Parser, ValueHint};
 use eyre::Result;
 use foundry_cli::opts::BuildOpts;
-use foundry_config::{impl_figment_convert, lint::FailOn};
+use foundry_config::{impl_figment_convert, lint::DenyLevel};
 use std::path::PathBuf;
 
 /// CLI arguments for `forge geiger`.
@@ -51,7 +51,7 @@ impl GeigerArgs {
             lint: Some(vec!["unsafe-cheatcode".to_string()]),
             json: false,
             build: self.build,
-            fail_on: Some(FailOn::Note),
+            deny: Some(DenyLevel::Notes),
         };
 
         // Run the lint command with the geiger-specific configuration

crates/forge/src/cmd/lint.rs

@@ -11,7 +11,7 @@ use foundry_cli::{
 use foundry_compilers::{solc::SolcLanguage, utils::SOLC_EXTENSIONS};
 use foundry_config::{
     filter::expand_globs,
-    lint::{FailOn, Severity},
+    lint::{DenyLevel, Severity},
 };
 use std::path::PathBuf;
 
@@ -40,7 +40,7 @@ pub struct LintArgs {
     /// Specifies the minimum diagnostic level at which the process should finish with a non-zero.
     /// exit code.
     #[arg(long, value_name = "LEVEL")]
-    pub fail_on: Option<FailOn>,
+    pub deny: Option<DenyLevel>,
 
     #[command(flatten)]
     pub(crate) build: BuildOpts,
@@ -105,6 +105,13 @@ impl LintArgs {
         // Override default severity config with user-defined severity
         let severity = self.severity.unwrap_or(config.lint.severity.clone());
 
+        // Override default `deny` level config < `deny_warnings` config < user-defined `deny` level
+        let deny = self.deny.unwrap_or(if config.deny_warnings {
+            DenyLevel::Warnings
+        } else {
+            config.lint.deny
+        });
+
         if project.compiler.solc.is_none() {
             return Err(eyre!("Linting not supported for this language"));
         }
@@ -126,8 +133,7 @@ impl LintArgs {
             Ok(())
         })?;
 
-        // Override default fail_on level config with user-defined severity
-        linter.lint(&input, self.fail_on.unwrap_or(config.lint.fail_on), &mut compiler)?;
+        linter.lint(&input, deny, &mut compiler)?;
 
         Ok(())
     }

crates/forge/tests/cli/config.rs

@@ -1088,7 +1088,7 @@ severity = []
 exclude_lints = []
 ignore = []
 lint_on_build = true
-fail_on = "never"
+deny = "never"
 mixed_case_exceptions = ["ERC"]
 
 [doc]
@@ -1316,7 +1316,7 @@ exclude = []
     "exclude_lints": [],
     "ignore": [],
     "lint_on_build": true,
-    "fail_on": "never",
+    "deny": "never",
     "mixed_case_exceptions": [
       "ERC"
     ]

crates/forge/tests/cli/lint.rs

@@ -187,7 +187,7 @@ forgetest!(can_use_config_mixed_case_exception, |prj, cmd| {
             ignore: vec!["src/ContractWithLints.sol".into()],
             lint_on_build: true,
             mixed_case_exceptions: vec!["MIXED".to_string()],
-            fail_on: foundry_config::lint::FailOn::Never,
+            deny: foundry_config::lint::DenyLevel::Never,
         };
     });
     cmd.arg("lint").assert_success().stderr_eq(str![[""]]);
@@ -537,34 +537,34 @@ forgetest!(can_fail_on_lints, |prj, cmd| {
 
     // -- LINT ALL SEVERITIES [OUTPUT: WARN + NOTE] ----------------------------
 
-    cmd.forge_fuse().arg("lint").assert_success(); // FailOn::Never (default)
+    cmd.forge_fuse().arg("lint").assert_success(); // DenyLevel::Never (default)
 
     prj.update_config(|config| {
-        config.lint.fail_on = foundry_config::lint::FailOn::Warning;
+        config.lint.deny = foundry_config::lint::DenyLevel::Warnings;
     });
     cmd.forge_fuse().arg("lint").assert_failure();
 
     prj.update_config(|config| {
-        config.lint.fail_on = foundry_config::lint::FailOn::Note;
+        config.lint.deny = foundry_config::lint::DenyLevel::Notes;
     });
 
     cmd.forge_fuse().arg("lint").assert_failure();
 
     // -- ONLY LINT LOW SEVERITIES [OUTPUT: NOTE] ------------------------------
 
     prj.update_config(|config| {
-        config.lint.fail_on = foundry_config::lint::FailOn::Never;
+        config.lint.deny = foundry_config::lint::DenyLevel::Never;
         config.lint.severity = vec![LintSeverity::Info, LintSeverity::Gas, LintSeverity::CodeSize];
     });
     cmd.forge_fuse().arg("lint").assert_success();
 
     prj.update_config(|config| {
-        config.lint.fail_on = foundry_config::lint::FailOn::Warning;
+        config.lint.deny = foundry_config::lint::DenyLevel::Warnings;
     });
     cmd.forge_fuse().arg("lint").assert_success();
 
     prj.update_config(|config| {
-        config.lint.fail_on = foundry_config::lint::FailOn::Note;
+        config.lint.deny = foundry_config::lint::DenyLevel::Notes;
     });
     cmd.forge_fuse().arg("lint").assert_failure();
 });

crates/lint/src/linter/mod.rs

@@ -6,7 +6,7 @@ pub use late::{LateLintPass, LateLintVisitor};
 
 use eyre::Result;
 use foundry_compilers::Language;
-use foundry_config::lint::{FailOn, Severity};
+use foundry_config::lint::{DenyLevel, Severity};
 use solar::{
     interface::{
         Session, Span,
@@ -43,8 +43,8 @@ pub trait Linter: Send + Sync {
     /// The `compiler` should have already been configured with all the sources necessary,
     /// as well as having performed parsing and lowering.
     ///
-    /// Should return an error based on the configured [`FailOn`] level and the emitted diagnostics.
-    fn lint(&self, input: &[PathBuf], fail_on: FailOn, compiler: &mut Compiler) -> Result<()>;
+    /// Should return an error based on the configured [`DenyLevel`] and the emitted diagnostics.
+    fn lint(&self, input: &[PathBuf], deny: DenyLevel, compiler: &mut Compiler) -> Result<()>;
 }
 
 pub trait Lint {

crates/lint/src/sol/mod.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use foundry_common::comments::Comments;
 use foundry_compilers::{ProjectPathsConfig, solc::SolcLanguage};
-use foundry_config::lint::{FailOn, Severity};
+use foundry_config::lint::{DenyLevel, Severity};
 use rayon::prelude::*;
 use solar::{
     ast::{self as ast, visit::Visit as VisitAST},
@@ -239,7 +239,7 @@ impl<'a> Linter for SolidityLinter<'a> {
     fn lint(
         &self,
         input: &[PathBuf],
-        fail_on: FailOn,
+        deny: DenyLevel,
         compiler: &mut Compiler,
     ) -> eyre::Result<()> {
         compiler.enter_mut(|compiler| {
@@ -266,18 +266,18 @@ impl<'a> Linter for SolidityLinter<'a> {
 
         // Handle diagnostics and fail if necessary.
         const MSG: &str = "aborting due to ";
-        match (fail_on, compiler.dcx().warn_count(), compiler.dcx().note_count()) {
-            // Fail on warnings.
-            (FailOn::Warning, w, n) if w > 0 => {
+        match (deny, compiler.dcx().warn_count(), compiler.dcx().note_count()) {
+            // Deny warnings.
+            (DenyLevel::Warnings, w, n) if w > 0 => {
                 if n > 0 {
                     Err(eyre::eyre!("{MSG}{w} linter warning(s); {n} note(s) were also emitted\n"))
                 } else {
                     Err(eyre::eyre!("{MSG}{w} linter warning(s)\n"))
                 }
             }
 
-            // Fail on any diagnostic.
-            (FailOn::Note, w, n) if w > 0 || n > 0 => match (w, n) {
+            // Deny any diagnostic.
+            (DenyLevel::Notes, w, n) if w > 0 || n > 0 => match (w, n) {
                 (w, n) if w > 0 && n > 0 => {
                     Err(eyre::eyre!("{MSG}{w} linter warning(s) and {n} note(s)\n"))
                 }