revise: lint rules can be enabled/disabled via TagSet

a-frantz · a-frantz · commit 1f776d6cda69 · 2025-09-03T21:08:07.000-04:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -80,6 +80,7 @@ serde_json = "1.0.140"
 serde_with = "3.14.0"
 serde_yaml_ng = "0.10.0"
 shellexpand = "3.1.1"
+strum = { version = "0.27", features = ["derive"] }
 strsim = "0.11.1"
 sysinfo = "0.37.0"
 tempfile = "3.21.0"
diff --git a/wdl-cli/src/analysis.rs b/wdl-cli/src/analysis.rs
@@ -18,6 +18,7 @@ mod source;
 
 pub use results::AnalysisResults;
 pub use source::Source;
+use wdl_lint::TagSet;
 
 /// The type of the initialization callback.
 type InitCb = Box<dyn Fn() + 'static>;
@@ -36,8 +37,11 @@ pub struct Analysis {
     /// A list of rules to except.
     exceptions: HashSet<String>,
 
-    /// Whether or not to enable linting.
-    lint: bool,
+    /// Which lint rules to enable, as specified via a [`TagSet`].
+    enabled_lint_tags: TagSet,
+
+    /// Which lint rules to disable, as specified via a [`TagSet`].
+    disabled_lint_tags: TagSet,
 
     /// Basename for any ignorefiles which should be respected.
     ignore_filename: Option<String>,
@@ -74,12 +78,6 @@ impl Analysis {
         self
     }
 
-    /// Sets whether linting is enabled.
-    pub fn lint(mut self, value: bool) -> Self {
-        self.lint = value;
-        self
-    }
-
     /// Sets the ignorefile basename.
     pub fn ignore_filename(mut self, filename: Option<String>) -> Self {
         self.ignore_filename = filename;
@@ -104,6 +102,18 @@ impl Analysis {
         self
     }
 
+    /// Sets the enabled lint tags.
+    pub fn enabled_lint_tags(mut self, tags: TagSet) -> Self {
+        self.enabled_lint_tags = tags;
+        self
+    }
+
+    /// Sets the disabled lint tags.
+    pub fn disabled_lint_tags(mut self, tags: TagSet) -> Self {
+        self.disabled_lint_tags = tags;
+        self
+    }
+
     /// Runs the analysis and returns all results (if any exist).
     pub async fn run(self) -> std::result::Result<AnalysisResults, NonEmpty<Arc<Error>>> {
         warn_unknown_rules(&self.exceptions);
@@ -116,8 +126,12 @@ impl Analysis {
         let validator = Box::new(move || {
             let mut validator = Validator::default();
 
-            if self.lint {
-                let visitor = get_lint_visitor(&self.exceptions);
+            if self.enabled_lint_tags.count() > 0 {
+                let visitor = get_lint_visitor(
+                    &self.enabled_lint_tags,
+                    &self.disabled_lint_tags,
+                    &self.exceptions,
+                );
                 validator.add_visitor(visitor);
             }
 
@@ -150,7 +164,8 @@ impl Default for Analysis {
         Self {
             sources: Default::default(),
             exceptions: Default::default(),
-            lint: Default::default(),
+            enabled_lint_tags: TagSet::new(&[]),
+            disabled_lint_tags: TagSet::new(&[]),
             ignore_filename: None,
             init: Box::new(|| {}),
             progress: Box::new(|_, _, _| Box::pin(async {})),
@@ -195,10 +210,16 @@ fn get_diagnostics_config(exceptions: &HashSet<String>) -> DiagnosticsConfig {
 }
 
 /// Gets a lint visitor with the excepted rules removed.
-fn get_lint_visitor(exceptions: &HashSet<String>) -> Linter {
+fn get_lint_visitor(
+    enabled_lint_tags: &TagSet,
+    disabled_lint_tags: &TagSet,
+    exceptions: &HashSet<String>,
+) -> Linter {
     Linter::new(wdl_lint::rules().into_iter().filter(|rule| {
-        !exceptions
-            .iter()
-            .any(|exception| exception.eq_ignore_ascii_case(rule.id()))
+        enabled_lint_tags.intersect(rule.tags()).count() > 0
+            && disabled_lint_tags.intersect(rule.tags()).count() == 0
+            && !exceptions
+                .iter()
+                .any(|exception| exception.eq_ignore_ascii_case(rule.id()))
     }))
 }
diff --git a/wdl-grammar/Cargo.toml b/wdl-grammar/Cargo.toml
@@ -19,7 +19,7 @@ logos = { workspace = true }
 rowan = { workspace = true }
 serde = { workspace = true }
 serde_with = { workspace = true }
-strum = { version = "0.27", features = ["derive"] }
+strum = { workspace = true }
 
 [dev-dependencies]
 anyhow = { workspace = true }
diff --git a/wdl-lint/Cargo.toml b/wdl-lint/Cargo.toml
@@ -23,6 +23,7 @@ rand = { workspace = true }
 rowan = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+strum = { workspace = true }
 strsim = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
diff --git a/wdl-lint/src/rules/comment_whitespace.rs b/wdl-lint/src/rules/comment_whitespace.rs
@@ -87,7 +87,7 @@ impl Rule for CommentWhitespaceRule {
     }
 
     fn tags(&self) -> TagSet {
-        TagSet::new(&[Tag::Spacing])
+        TagSet::new(&[Tag::Spacing, Tag::Style])
     }
 
     fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {
diff --git a/wdl-lint/src/rules/element_spacing.rs b/wdl-lint/src/rules/element_spacing.rs
@@ -99,7 +99,7 @@ impl Rule for ElementSpacingRule {
     }
 
     fn tags(&self) -> TagSet {
-        TagSet::new(&[Tag::Spacing])
+        TagSet::new(&[Tag::Spacing, Tag::Style])
     }
 
     fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {
diff --git a/wdl-lint/src/rules/ending_newline.rs b/wdl-lint/src/rules/ending_newline.rs
@@ -59,7 +59,7 @@ impl Rule for EndingNewlineRule {
     }
 
     fn tags(&self) -> TagSet {
-        TagSet::new(&[Tag::Spacing, Tag::Style])
+        TagSet::new(&[Tag::Spacing, Tag::Portability])
     }
 
     fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {
diff --git a/wdl-lint/src/rules/expression_spacing.rs b/wdl-lint/src/rules/expression_spacing.rs
@@ -194,7 +194,7 @@ impl Rule for ExpressionSpacingRule {
     }
 
     fn tags(&self) -> TagSet {
-        TagSet::new(&[Tag::Spacing])
+        TagSet::new(&[Tag::Spacing, Tag::Style])
     }
 
     fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {
diff --git a/wdl-lint/src/rules/input_name.rs b/wdl-lint/src/rules/input_name.rs
@@ -70,7 +70,7 @@ impl Rule for InputNameRule {
     }
 
     fn tags(&self) -> TagSet {
-        TagSet::new(&[Tag::Naming])
+        TagSet::new(&[Tag::Naming, Tag::Style])
     }
 
     fn exceptable_nodes(&self) -> Option<&'static [wdl_ast::SyntaxKind]> {
diff --git a/wdl-lint/src/rules/output_name.rs b/wdl-lint/src/rules/output_name.rs
@@ -70,7 +70,7 @@ impl Rule for OutputNameRule {
     }
 
     fn tags(&self) -> TagSet {
-        TagSet::new(&[Tag::Naming])
+        TagSet::new(&[Tag::Naming, Tag::Style])
     }
 
     fn exceptable_nodes(&self) -> Option<&'static [wdl_ast::SyntaxKind]> {
diff --git a/wdl-lint/src/tags.rs b/wdl-lint/src/tags.rs
@@ -1,7 +1,9 @@
 //! Definition of lint rule tags.
 
+use strum::VariantArray;
+
 /// A lint rule tag.
-#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[derive(VariantArray, Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 #[repr(u8)]
 pub enum Tag {
     /// Rules associated with having a complete document.
@@ -90,22 +92,15 @@ pub struct TagSet(u32);
 
 impl TagSet {
     /// Constructs a tag set from a slice of tags.
-    ///
-    /// # Panics
-    ///
-    /// This method will panic if the provided slice is empty.
     pub const fn new(tags: &[Tag]) -> Self {
         if tags.is_empty() {
-            panic!("a tag set must be non-empty");
+            return Self(0);
         }
 
         let mut bits = 0u32;
         let mut i = 0;
         while i < tags.len() {
             bits |= Self::mask(tags[i]);
-            if matches!(tags[i], Tag::Naming | Tag::Spacing) {
-                bits |= Self::mask(Tag::Style);
-            }
             i += 1;
         }
         Self(bits)
@@ -116,6 +111,11 @@ impl TagSet {
         Self(self.0 | other.0)
     }
 
+    /// Intersects two tag sets.
+    pub const fn intersect(self, other: Self) -> Self {
+        Self(self.0 & other.0)
+    }
+
     /// Checks if the tag is contained in the set.
     pub const fn contains(&self, tag: Tag) -> bool {
         self.0 & Self::mask(tag) != 0
@@ -160,3 +160,48 @@ impl std::fmt::Display for TagSet {
         write!(f, "{tags:?}")
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn it_unions() {
+        let a = TagSet::new(&[Tag::Clarity, Tag::Completeness]);
+        assert_eq!(a.count(), 2);
+        let b = TagSet::new(&[Tag::Clarity, Tag::Deprecated]);
+        assert_eq!(b.count(), 2);
+
+        let union = a.union(b);
+        assert_eq!(
+            union,
+            TagSet::new(&[Tag::Clarity, Tag::Completeness, Tag::Deprecated])
+        );
+        assert_eq!(union.count(), 3);
+    }
+
+    #[test]
+    fn it_intersects() {
+        let a = TagSet::new(&[Tag::Clarity, Tag::Completeness]);
+        assert_eq!(a.count(), 2);
+        let b = TagSet::new(&[Tag::Clarity, Tag::Deprecated]);
+        assert_eq!(b.count(), 2);
+
+        let intersection = a.intersect(b);
+
+        assert_eq!(intersection, TagSet::new(&[Tag::Clarity]));
+        assert_eq!(intersection.count(), 1);
+    }
+
+    #[test]
+    fn empty_slice_behaves() {
+        let a = TagSet::new(&[]);
+        assert_eq!(a.0, 0u32);
+
+        let b = TagSet::new(&[]);
+        assert_eq!(a, b);
+        assert_eq!(a, b.intersect(a));
+        assert_eq!(b, a.union(b));
+        assert_eq!(a.count(), 0);
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ impl Rule for CommentWhitespaceRule {`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`fn tags(&self) -> TagSet {`
`90`		`- TagSet::new(&[Tag::Spacing])`
	`90`	`+ TagSet::new(&[Tag::Spacing, Tag::Style])`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ impl Rule for ElementSpacingRule {`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`fn tags(&self) -> TagSet {`
`102`		`- TagSet::new(&[Tag::Spacing])`
	`102`	`+ TagSet::new(&[Tag::Spacing, Tag::Style])`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ impl Rule for EndingNewlineRule {`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`fn tags(&self) -> TagSet {`
`62`		`- TagSet::new(&[Tag::Spacing, Tag::Style])`
	`62`	`+ TagSet::new(&[Tag::Spacing, Tag::Portability])`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {`
Original file line number	Diff line number	Diff line change
`@@ -194,7 +194,7 @@ impl Rule for ExpressionSpacingRule {`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`fn tags(&self) -> TagSet {`
`197`		`- TagSet::new(&[Tag::Spacing])`
	`197`	`+ TagSet::new(&[Tag::Spacing, Tag::Style])`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`fn exceptable_nodes(&self) -> Option<&'static [SyntaxKind]> {`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ impl Rule for InputNameRule {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`fn tags(&self) -> TagSet {`
`73`		`- TagSet::new(&[Tag::Naming])`
	`73`	`+ TagSet::new(&[Tag::Naming, Tag::Style])`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`fn exceptable_nodes(&self) -> Option<&'static [wdl_ast::SyntaxKind]> {`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ impl Rule for OutputNameRule {`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`fn tags(&self) -> TagSet {`
`73`		`- TagSet::new(&[Tag::Naming])`
	`73`	`+ TagSet::new(&[Tag::Naming, Tag::Style])`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`fn exceptable_nodes(&self) -> Option<&'static [wdl_ast::SyntaxKind]> {`