refactor(analyzer): use enumflags2

crates/biome_analyze/Cargo.toml

@@ -18,7 +18,7 @@ biome_deserialize        = { workspace = true, optional = true }
 biome_deserialize_macros = { workspace = true, optional = true }
 biome_diagnostics        = { workspace = true }
 biome_rowan              = { workspace = true }
-bitflags                 = { workspace = true }
+enumflags2               = { workspace = true }
 rustc-hash               = { workspace = true }
 schemars                 = { workspace = true, optional = true }
 serde                    = { workspace = true, features = ["derive"], optional = true }

crates/biome_analyze/src/categories.rs

@@ -1,7 +1,6 @@
+use enumflags2::{bitflags, BitFlags};
 use std::borrow::Cow;
 
-use bitflags::bitflags;
-
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(
     feature = "serde",
@@ -172,13 +171,38 @@ pub enum SourceActionKind {
     Other(Cow<'static, str>),
 }
 
-bitflags! {
-    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
-    pub struct RuleCategories: u8 {
-        const SYNTAX = 1 << RuleCategory::Syntax as u8;
-        const LINT = 1 << RuleCategory::Lint as u8;
-        const ACTION = 1 << RuleCategory::Action as u8;
-        const TRANSFORMATION = 1 << RuleCategory::Transformation as u8;
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[bitflags]
+#[repr(u8)]
+pub(crate) enum Categories {
+    Syntax = 1 << RuleCategory::Syntax as u8,
+    Lint = 1 << RuleCategory::Lint as u8,
+    Action = 1 << RuleCategory::Action as u8,
+    Transformation = 1 << RuleCategory::Transformation as u8,
+}
+
+#[derive(Debug, Copy, Clone)]
+/// The categories supported by the analyzer.
+///
+/// The default implementation of this type returns an instance with all the categories.
+///
+/// Use [RuleCategoriesBuilder] to generate the categories you want to query.
+pub struct RuleCategories(BitFlags<Categories>);
+
+impl RuleCategories {
+    pub fn empty() -> Self {
+        let empty: BitFlags<Categories> = BitFlags::empty();
+        Self(empty)
+    }
+
+    pub fn all() -> Self {
+        let empty: BitFlags<Categories> = BitFlags::all();
+        Self(empty)
+    }
+
+    /// Checks whether the current categories contain a specific [RuleCategories]
+    pub fn contains(&self, other: impl Into<RuleCategories>) -> bool {
+        self.0.contains(other.into().0)
     }
 }
 
@@ -190,17 +214,19 @@ impl Default for RuleCategories {
 
 impl RuleCategories {
     pub fn is_syntax(&self) -> bool {
-        *self == RuleCategories::SYNTAX
+        self.0.contains(Categories::Syntax)
     }
 }
 
 impl From<RuleCategory> for RuleCategories {
     fn from(input: RuleCategory) -> Self {
         match input {
-            RuleCategory::Syntax => RuleCategories::SYNTAX,
-            RuleCategory::Lint => RuleCategories::LINT,
-            RuleCategory::Action => RuleCategories::ACTION,
-            RuleCategory::Transformation => RuleCategories::TRANSFORMATION,
+            RuleCategory::Syntax => RuleCategories(BitFlags::from_flag(Categories::Syntax)),
+            RuleCategory::Lint => RuleCategories(BitFlags::from_flag(Categories::Lint)),
+            RuleCategory::Action => RuleCategories(BitFlags::from_flag(Categories::Action)),
+            RuleCategory::Transformation => {
+                RuleCategories(BitFlags::from_flag(Categories::Transformation))
+            }
         }
     }
 }
@@ -213,19 +239,19 @@ impl serde::Serialize for RuleCategories {
     {
         let mut flags = Vec::new();
 
-        if self.contains(Self::SYNTAX) {
+        if self.0.contains(Categories::Syntax) {
             flags.push(RuleCategory::Syntax);
         }
 
-        if self.contains(Self::LINT) {
+        if self.0.contains(Categories::Lint) {
             flags.push(RuleCategory::Lint);
         }
 
-        if self.contains(Self::ACTION) {
+        if self.0.contains(Categories::Action) {
             flags.push(RuleCategory::Action);
         }
 
-        if self.contains(Self::TRANSFORMATION) {
+        if self.0.contains(Categories::Transformation) {
             flags.push(RuleCategory::Transformation);
         }
 
@@ -258,7 +284,7 @@ impl<'de> serde::Deserialize<'de> for RuleCategories {
                 let mut result = RuleCategories::empty();
 
                 while let Some(item) = seq.next_element::<RuleCategory>()? {
-                    result |= RuleCategories::from(item);
+                    result.0 |= RuleCategories::from(item).0;
                 }
 
                 Ok(result)
@@ -279,3 +305,45 @@ impl schemars::JsonSchema for RuleCategories {
         <Vec<RuleCategory>>::json_schema(gen)
     }
 }
+
+#[derive(Debug, Default)]
+/// A convenient type create a [RuleCategories] type
+///
+/// ```
+/// use biome_analyze::{RuleCategoriesBuilder, RuleCategory};
+/// let mut categories = RuleCategoriesBuilder::default().with_syntax().with_lint().build();
+///
+/// assert!(categories.contains(RuleCategory::Lint));
+/// assert!(categories.contains(RuleCategory::Syntax));
+/// assert!(!categories.contains(RuleCategory::Action));
+/// assert!(!categories.contains(RuleCategory::Transformation));
+/// ```
+pub struct RuleCategoriesBuilder {
+    flags: BitFlags<Categories>,
+}
+
+impl RuleCategoriesBuilder {
+    pub fn with_syntax(mut self) -> Self {
+        self.flags.insert(Categories::Syntax);
+        self
+    }
+
+    pub fn with_lint(mut self) -> Self {
+        self.flags.insert(Categories::Lint);
+        self
+    }
+
+    pub fn with_action(mut self) -> Self {
+        self.flags.insert(Categories::Action);
+        self
+    }
+
+    pub fn with_transformation(mut self) -> Self {
+        self.flags.insert(Categories::Transformation);
+        self
+    }
+
+    pub fn build(self) -> RuleCategories {
+        RuleCategories(self.flags)
+    }
+}

crates/biome_analyze/src/lib.rs

@@ -24,7 +24,8 @@ mod visitor;
 pub use biome_diagnostics::category_concat;
 
 pub use crate::categories::{
-    ActionCategory, RefactorKind, RuleCategories, RuleCategory, SourceActionKind,
+    ActionCategory, RefactorKind, RuleCategories, RuleCategoriesBuilder, RuleCategory,
+    SourceActionKind,
 };
 pub use crate::diagnostics::AnalyzerDiagnostic;
 pub use crate::diagnostics::SuppressionDiagnostic;
@@ -885,7 +886,7 @@ impl<'analysis> AnalysisFilter<'analysis> {
 
     /// Return `true` if the category `C` matches this filter
     pub fn match_category<C: GroupCategory>(&self) -> bool {
-        self.categories.contains(C::CATEGORY.into())
+        self.categories.contains(C::CATEGORY)
     }
 
     /// Return `true` if the group `G` matches this filter

crates/biome_cli/src/execute/process_file/format.rs

@@ -4,9 +4,9 @@ use crate::execute::process_file::{
     DiffKind, FileResult, FileStatus, Message, SharedTraversalOptions,
 };
 use crate::execute::TraversalMode;
+use biome_analyze::RuleCategoriesBuilder;
 use biome_diagnostics::{category, Diagnostic, DiagnosticExt, Error, Severity};
 use biome_service::file_handlers::{AstroFileHandler, SvelteFileHandler, VueFileHandler};
-use biome_service::workspace::RuleCategories;
 use std::path::Path;
 use std::sync::atomic::Ordering;
 use tracing::debug;
@@ -27,7 +27,7 @@ pub(crate) fn format_with_guard<'ctx>(
             let diagnostics_result = workspace_file
                 .guard()
                 .pull_diagnostics(
-                    RuleCategories::SYNTAX,
+                    RuleCategoriesBuilder::default().with_syntax().build(),
                     max_diagnostics.into(),
                     Vec::new(),
                     Vec::new(),

crates/biome_cli/src/execute/process_file/lint.rs

@@ -2,9 +2,9 @@ use crate::execute::diagnostics::ResultExt;
 use crate::execute::process_file::workspace_file::WorkspaceFile;
 use crate::execute::process_file::{FileResult, FileStatus, Message, SharedTraversalOptions};
 use crate::TraversalMode;
+use biome_analyze::RuleCategoriesBuilder;
 use biome_diagnostics::{category, Error};
 use biome_service::file_handlers::{AstroFileHandler, SvelteFileHandler, VueFileHandler};
-use biome_service::workspace::RuleCategories;
 use std::path::Path;
 use std::sync::atomic::Ordering;
 
@@ -66,7 +66,10 @@ pub(crate) fn lint_with_guard<'ctx>(
             let pull_diagnostics_result = workspace_file
                 .guard()
                 .pull_diagnostics(
-                    RuleCategories::LINT | RuleCategories::SYNTAX,
+                    RuleCategoriesBuilder::default()
+                        .with_syntax()
+                        .with_lint()
+                        .build(),
                     max_diagnostics.into(),
                     only,
                     skip,

crates/biome_cli/src/execute/std_in.rs

@@ -3,15 +3,15 @@
 use crate::execute::diagnostics::{ContentDiffAdvice, FormatDiffDiagnostic};
 use crate::execute::Execution;
 use crate::{CliDiagnostic, CliSession, TraversalMode};
+use biome_analyze::RuleCategoriesBuilder;
 use biome_console::{markup, ConsoleExt};
 use biome_diagnostics::PrintDiagnostic;
 use biome_diagnostics::{Diagnostic, DiagnosticExt, Error};
 use biome_fs::BiomePath;
 use biome_service::file_handlers::{AstroFileHandler, SvelteFileHandler, VueFileHandler};
 use biome_service::workspace::{
     ChangeFileParams, DropPatternParams, FeaturesBuilder, FixFileParams, FormatFileParams,
-    OpenFileParams, OrganizeImportsParams, PullDiagnosticsParams, RuleCategories,
-    SupportsFeatureParams,
+    OpenFileParams, OrganizeImportsParams, PullDiagnosticsParams, SupportsFeatureParams,
 };
 use biome_service::WorkspaceError;
 use std::borrow::Cow;
@@ -163,7 +163,10 @@ pub(crate) fn run<'a>(
         };
         if !mode.is_check_apply_unsafe() {
             let result = workspace.pull_diagnostics(PullDiagnosticsParams {
-                categories: RuleCategories::LINT | RuleCategories::SYNTAX,
+                categories: RuleCategoriesBuilder::default()
+                    .with_lint()
+                    .with_syntax()
+                    .build(),
                 path: biome_path.clone(),
                 max_diagnostics: mode.max_diagnostics.into(),
                 only,

crates/biome_grit_parser/Cargo.toml

@@ -17,7 +17,6 @@ biome_grit_factory = { workspace = true }
 biome_grit_syntax  = { workspace = true }
 biome_parser       = { workspace = true }
 biome_rowan        = { workspace = true }
-bitflags           = { workspace = true }
 schemars           = { workspace = true, optional = true }
 serde              = { workspace = true, features = ["derive"] }
 serde_json         = { workspace = true }

crates/biome_js_analyze/src/lib.rs

@@ -230,7 +230,7 @@ impl Error for RuleError {}
 #[cfg(test)]
 mod tests {
     use biome_analyze::options::RuleOptions;
-    use biome_analyze::{AnalyzerOptions, Never, RuleCategories, RuleFilter, RuleKey};
+    use biome_analyze::{AnalyzerOptions, Never, RuleCategoriesBuilder, RuleFilter, RuleKey};
     use biome_console::fmt::{Formatter, Termcolor};
     use biome_console::{markup, Markup};
     use biome_diagnostics::category;
@@ -451,7 +451,7 @@ mod tests {
         );
 
         let filter = AnalysisFilter {
-            categories: RuleCategories::SYNTAX,
+            categories: RuleCategoriesBuilder::default().with_syntax().build(),
             ..AnalysisFilter::default()
         };
 

crates/biome_js_transform/src/lib.rs

@@ -120,7 +120,7 @@ pub(crate) type JsBatchMutation = BatchMutation<JsLanguage>;
 
 #[cfg(test)]
 mod tests {
-    use biome_analyze::{AnalyzerOptions, Never, RuleCategories, RuleFilter};
+    use biome_analyze::{AnalyzerOptions, Never, RuleCategoriesBuilder, RuleFilter};
     use biome_js_parser::{parse, JsParserOptions};
     use biome_js_syntax::JsFileSource;
     use std::slice;
@@ -140,7 +140,9 @@ mod tests {
         transform(
             &parsed.tree(),
             AnalysisFilter {
-                categories: RuleCategories::TRANSFORMATION,
+                categories: RuleCategoriesBuilder::default()
+                    .with_transformation()
+                    .build(),
                 enabled_rules: Some(slice::from_ref(&rule_filter)),
                 ..AnalysisFilter::default()
             },

crates/biome_lsp/src/session.rs

@@ -4,7 +4,7 @@ use crate::extension_settings::ExtensionSettings;
 use crate::extension_settings::CONFIGURATION_SECTION;
 use crate::utils;
 use anyhow::Result;
-use biome_analyze::RuleCategories;
+use biome_analyze::RuleCategoriesBuilder;
 use biome_configuration::ConfigurationPathHint;
 use biome_console::markup;
 use biome_diagnostics::PrintDescription;
@@ -316,18 +316,18 @@ impl Session {
         })?;
 
         let diagnostics: Vec<Diagnostic> = {
-            let mut categories = RuleCategories::SYNTAX;
+            let mut categories = RuleCategoriesBuilder::default().with_syntax();
             if self.configuration_status().is_loaded() {
                 if file_features.supports_lint() {
-                    categories |= RuleCategories::LINT
+                    categories = categories.with_lint();
                 }
                 if file_features.supports_organize_imports() {
-                    categories |= RuleCategories::ACTION
+                    categories = categories.with_action();
                 }
             }
             let result = self.workspace.pull_diagnostics(PullDiagnosticsParams {
                 path: biome_path.clone(),
-                categories,
+                categories: categories.build(),
                 max_diagnostics: u64::MAX,
                 only: Vec::new(),
                 skip: Vec::new(),

crates/biome_service/src/file_handlers/css.rs

@@ -18,7 +18,8 @@ use crate::workspace::{
 use crate::WorkspaceError;
 use biome_analyze::options::PreferredQuote;
 use biome_analyze::{
-    AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never, RuleCategories,
+    AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never,
+    RuleCategoriesBuilder, RuleCategory,
 };
 use biome_css_analyze::analyze;
 use biome_css_formatter::context::CssFormatOptions;
@@ -386,7 +387,7 @@ fn lint(params: LintParams) -> LintResults {
             // - it is a syntax-only analyzer pass, or
             // - if a single rule is run.
             let ignores_suppression_comment =
-                !filter.categories.contains(RuleCategories::LINT) || has_only_filter;
+                !filter.categories.contains(RuleCategory::Lint) || has_only_filter;
 
             let mut diagnostic_count = diagnostics.len() as u32;
             let mut errors = diagnostics
@@ -488,10 +489,11 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 
             let mut filter = AnalysisFilter::from_enabled_rules(filter.as_slice());
 
-            filter.categories = RuleCategories::SYNTAX | RuleCategories::LINT;
+            let mut categories = RuleCategoriesBuilder::default().with_syntax().with_lint();
             if settings.organize_imports.enabled {
-                filter.categories |= RuleCategories::ACTION;
+                categories = categories.with_action();
             }
+            filter.categories = categories.build();
             filter.range = Some(range);
 
             let analyzer_options = workspace.analyzer_options::<CssLanguage>(path, &language);