add warning category deny and allow

Author: stringhandler

src/ast.rs

@@ -763,15 +763,36 @@ impl Scope {
     }
 }
 
+/// Category of a warning, used for per-class allow/deny control.
+///
+/// Unlike [`WarningName`], which carries instance-specific data for display,
+/// `WarnCategory` is a unit enum that identifies the *class* of warning so that
+/// callers can write `template.deny_warning(WarnCategory::UnusedVariable)` without
+/// needing a concrete identifier.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum WarnCategory {
+    /// A variable was bound but never used.
+    UnusedVariable,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum WarningName {
     VariableUnused(Identifier),
 }
 
+impl WarningName {
+    /// Return the category this warning belongs to.
+    pub fn category(&self) -> WarnCategory {
+        match self {
+            WarningName::VariableUnused(_) => WarnCategory::UnusedVariable,
+        }
+    }
+}
+
 impl fmt::Display for WarningName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            WarningName::VariableUnused(identifier) => write!(f, "Variable `{identifier}` is bound but never used. Prefix the variable name with `_` to silence this warning."),
+            WarningName::VariableUnused(identifier) => write!(f, "unused variable: `{identifier}`. Prefix the variable name with `_` to silence this warning."),
         }
     }
 }

src/lib.rs

@@ -29,6 +29,7 @@ pub extern crate either;
 pub extern crate simplicity;
 pub use simplicity::elements;
 
+pub use crate::ast::WarnCategory;
 use crate::ast::Warning;
 use crate::debug::DebugSymbols;
 use crate::error::{ErrorCollector, WithFile, WithFilePath};
@@ -89,7 +90,7 @@ impl TemplateProgram {
         }
     }
 
-    /// Treat any warnings as hard errors.
+    /// Treat all warnings as hard errors.
     ///
     /// Returns `self` unchanged if there are no warnings.
     ///
@@ -106,6 +107,39 @@ impl TemplateProgram {
         Err(ErrorCollector::to_string(&error_handler))
     }
 
+    /// Treat warnings of the given category as hard errors.
+    ///
+    /// Returns `self` unchanged if no warnings of that category exist.
+    ///
+    /// ## Errors
+    ///
+    /// The program produced one or more warnings in the given category.
+    pub fn deny_warning(self, category: WarnCategory) -> Result<Self, String> {
+        let matching: Vec<_> = self
+            .warnings
+            .iter()
+            .filter(|w| w.canonical_name.category() == category)
+            .cloned()
+            .collect();
+        if matching.is_empty() {
+            return Ok(self);
+        }
+        let mut error_handler =
+            ErrorCollector::new_with_path(Arc::clone(&self.file), Arc::clone(&self.file_path));
+        error_handler.update(matching.into_iter().map(|w| w.into()));
+        Err(ErrorCollector::to_string(&error_handler))
+    }
+
+    /// Silence warnings of the given category.
+    ///
+    /// The matching warnings are removed from [`TemplateProgram::warnings`] and will
+    /// not appear in [`format_warnings`](Self::format_warnings) output.
+    pub fn allow_warning(mut self, category: WarnCategory) -> Self {
+        self.warnings
+            .retain(|w| w.canonical_name.category() != category);
+        self
+    }
+
     /// Access the parameters of the program.
     pub fn parameters(&self) -> &Parameters {
         self.simfony.parameters()
@@ -968,6 +1002,38 @@ fn main() {
 }"#;
             assert!(warning_names(prog).is_empty());
         }
+
+        #[test]
+        fn deny_warning_by_category_is_error() {
+            use crate::WarnCategory;
+            let prog = r#"fn main() {
+    let (carry, sum): (bool, u8) = jet::add_8(2, 3);
+    assert!(jet::eq_8(sum, 5))
+}"#;
+            assert!(
+                TemplateProgram::new(prog)
+                    .unwrap()
+                    .deny_warning(WarnCategory::UnusedVariable)
+                    .is_err(),
+                "deny_warning(UnusedVariable) should fail when there is an unused variable",
+            );
+        }
+
+        #[test]
+        fn allow_warning_by_category_suppresses_it() {
+            use crate::WarnCategory;
+            let prog = r#"fn main() {
+    let (carry, sum): (bool, u8) = jet::add_8(2, 3);
+    assert!(jet::eq_8(sum, 5))
+}"#;
+            let template = TemplateProgram::new(prog)
+                .unwrap()
+                .allow_warning(WarnCategory::UnusedVariable);
+            assert!(
+                template.warnings().is_empty(),
+                "allow_warning(UnusedVariable) should remove the warning",
+            );
+        }
     }
 
     #[cfg(feature = "serde")]

src/main.rs

@@ -2,7 +2,7 @@ use base64::display::Base64Display;
 use base64::engine::general_purpose::STANDARD;
 use clap::{Arg, ArgAction, Command};
 
-use simplicityhl::{AbiMeta, TemplateProgram};
+use simplicityhl::{AbiMeta, TemplateProgram, WarnCategory};
 use std::{env, fmt};
 
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]
@@ -89,6 +89,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                     .action(ArgAction::SetTrue)
                     .help("Treat warnings as errors"),
             )
+            .arg(
+                Arg::new("deny_warning")
+                    .long("deny-warning")
+                    .value_name("CATEGORY")
+                    .action(ArgAction::Append)
+                    .help("Treat warnings of a specific category as errors (unused-variable)"),
+            )
+            .arg(
+                Arg::new("allow_warning")
+                    .long("allow-warning")
+                    .value_name("CATEGORY")
+                    .action(ArgAction::Append)
+                    .help("Silence warnings of a specific category (unused-variable)"),
+            )
     };
 
     let matches = command.get_matches();
@@ -121,13 +135,55 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let deny_warnings = matches.get_flag("deny_warnings");
 
+    fn parse_warn_category(s: &str) -> Result<WarnCategory, String> {
+        match s {
+            "unused-variable" => Ok(WarnCategory::UnusedVariable),
+            other => Err(format!(
+                "unknown warning category `{other}`; valid categories: unused-variable"
+            )),
+        }
+    }
+
+    let deny_categories: Vec<WarnCategory> = matches
+        .get_many::<String>("deny_warning")
+        .unwrap_or_default()
+        .map(|s| parse_warn_category(s))
+        .collect::<Result<_, _>>()
+        .unwrap_or_else(|e| {
+            eprintln!("\x1b[1;31merror\x1b[0m: {e}");
+            std::process::exit(1);
+        });
+
+    let allow_categories: Vec<WarnCategory> = matches
+        .get_many::<String>("allow_warning")
+        .unwrap_or_default()
+        .map(|s| parse_warn_category(s))
+        .collect::<Result<_, _>>()
+        .unwrap_or_else(|e| {
+            eprintln!("\x1b[1;31merror\x1b[0m: {e}");
+            std::process::exit(1);
+        });
+
     let template = match TemplateProgram::new_with_path(prog_text, prog_file.as_str()) {
         Ok(t) => t,
         Err(e) => {
             eprintln!("{}", e);
             std::process::exit(1);
         }
     };
+
+    let template = allow_categories
+        .iter()
+        .fold(template, |t, &cat| t.allow_warning(cat));
+
+    let template = deny_categories
+        .iter()
+        .fold(Ok(template), |t, &cat| t.and_then(|t| t.deny_warning(cat)))
+        .unwrap_or_else(|e| {
+            eprintln!("{e}");
+            std::process::exit(1);
+        });
+
     let n_warnings = template.warnings().len();
     if n_warnings > 0 {
         eprint!("{}", template.format_warnings(prog_file));