From ed0388263174794c9b88d55e68400cbebd4481ea Mon Sep 17 00:00:00 2001
From: Victorien Elvinger <victorien@elvinger.fr>
Date: Thu, 23 May 2024 16:39:58 +0200
Subject: [PATCH] refactor: `--only=<GROUP>` run all rules of a group

---
 crates/biome_cli/src/commands/mod.rs          |    8 +-
 crates/biome_cli/src/execute/mod.rs           |    7 +-
 .../main_commands_lint/lint_help.snap         |    8 +-
 .../lint_only_group_with_disabled_rule.snap   |   34 +
 .../biome_configuration/src/linter/rules.rs   | 1862 +----------------
 crates/biome_service/src/file_handlers/css.rs |   32 +-
 .../src/file_handlers/javascript.rs           |   29 +-
 .../biome_service/src/file_handlers/json.rs   |   38 +-
 crates/biome_service/src/file_handlers/mod.rs |   44 +-
 xtask/codegen/src/generate_configuration.rs   |   38 +-
 10 files changed, 112 insertions(+), 1988 deletions(-)

diff --git a/crates/biome_cli/src/commands/mod.rs b/crates/biome_cli/src/commands/mod.rs
index 5630d968a5f5..215230e0669c 100644
--- a/crates/biome_cli/src/commands/mod.rs
+++ b/crates/biome_cli/src/commands/mod.rs
@@ -193,11 +193,9 @@ pub enum BiomeCommand {
         #[bpaf(external, hide_usage)]
         cli_options: CliOptions,
 
-        /// Run only the given rule or rule group.
-        ///
-        /// When a rule is passed, its severity level is set to `error' if it is a recommended rule, or `warn' otherwise.
-        ///
-        /// When a rule group is passed, the `recommended` flag is enabled, but if the `all` flag is enabled.
+        /// Run only the given rule or group of rules.
+        /// If the severity level of a rule is `off`,
+        /// then the severity level of the rule is set to `error` if it is a recommended rule or `warn` otherwise.
         ///
         /// Example: `biome lint --only=correctness/noUnusedVariables --only=suspicious`
         #[bpaf(long("only"), argument("GROUP|RULE"))]
diff --git a/crates/biome_cli/src/execute/mod.rs b/crates/biome_cli/src/execute/mod.rs
index 62ab419eb09b..e4d2a34a2590 100644
--- a/crates/biome_cli/src/execute/mod.rs
+++ b/crates/biome_cli/src/execute/mod.rs
@@ -127,10 +127,9 @@ pub enum TraversalMode {
         /// 1. The virtual path to the file
         /// 2. The content of the file
         stdin: Option<Stdin>,
-        /// Run only the given rule or rule group.
-        /// The option overrides the Biome configuration file as follows:
-        /// - When a rule is passed, its severity level is set to `error' if it is a recommended rule, or `warn' otherwise.
-        /// - When a rule group is passed, the `recommended` flag is enabled, but if the `all` flag is enabled.
+        /// Run only the given rule or group of rules.
+        /// If the severity level of a rule is `off`,
+        /// then the severity level of the rule is set to `error` if it is a recommended rule or `warn` otherwise.
         only: Vec<RuleSelector>,
         /// Skip the given rule or group of rules by setting the severity level of the rules to `off`.
         /// This option takes precedence over `--only`.
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/lint_help.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_help.snap
index 9724dba2bd4d..316f2da0c85f 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_lint/lint_help.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_help.snap
@@ -72,11 +72,9 @@ Available options:
         --apply               Alias for `--write`, writes safe fixes (deprecated, use `--write`)
         --apply-unsafe        Alias for `--write --unsafe`, writes safe and unsafe fixes (deprecated,
                               use `--write --unsafe`)
-        --only=<GROUP|RULE>   Run only the given rule or rule group.
-                              When a rule is passed, its severity level is set to `error' if it is a
-                              recommended rule, or `warn' otherwise.
-                              When a rule group is passed, the `recommended` flag is enabled, but if
-                              the `all` flag is enabled.
+        --only=<GROUP|RULE>   Run only the given rule or group of rules. If the severity level of a rule
+                              is `off`, then the severity level of the rule is set to `error` if it is
+                              a recommended rule or `warn` otherwise.
                               Example: `biome lint --only=correctness/noUnusedVariables --only=suspicious`
         --skip=<GROUP|RULE>   Skip the given rule or group of rules by setting the severity level of
                               the rules to `off`. This option takes precedence over `--only`.
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/lint_only_group_with_disabled_rule.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_only_group_with_disabled_rule.snap
index 27f006ecb729..5007548c6627 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_lint/lint_only_group_with_disabled_rule.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/lint_only_group_with_disabled_rule.snap
@@ -24,10 +24,44 @@ expression: content
         debugger;
     }
     
+```
+
+# Termination Message
+
+```block
+lint ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × Some errors were emitted while running checks.
+  
+
+
 ```
 
 # Emitted Messages
 
+```block
+check.js:3:9 lint/suspicious/noDebugger  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × This is an unexpected use of the debugger statement.
+  
+    2 │     export function CONSTANT_CASE(){
+  > 3 │         debugger;
+      │         ^^^^^^^^^
+    4 │     }
+    5 │     
+  
+  i Unsafe fix: Remove debugger statement
+  
+    1 1 │   
+    2 2 │       export function CONSTANT_CASE(){
+    3   │ - ········debugger;
+    4 3 │       }
+    5 4 │       
+  
+
+```
+
 ```block
 Checked 1 file in <TIME>. No fixes needed.
+Found 1 error.
 ```
diff --git a/crates/biome_configuration/src/linter/rules.rs b/crates/biome_configuration/src/linter/rules.rs
index 312cb42a7e75..0c5abf4f699e 100644
--- a/crates/biome_configuration/src/linter/rules.rs
+++ b/crates/biome_configuration/src/linter/rules.rs
@@ -138,6 +138,8 @@ impl Rules {
     }
     #[doc = r" Given a category coming from [Diagnostic](biome_diagnostics::Diagnostic), this function returns"]
     #[doc = r" the [Severity](biome_diagnostics::Severity) associated to the rule, if the configuration changed it."]
+    #[doc = r" If the severity is off or not set, then the function returns the default severity of the rule:"]
+    #[doc = r" [Severity::Error] for recommended rules and [Severity::Warning] for other rules."]
     #[doc = r""]
     #[doc = r" If not, the function returns [None]."]
     pub fn get_severity_from_code(&self, category: &Category) -> Option<Severity> {
@@ -152,6 +154,7 @@ impl Rules {
                 .a11y
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if A11y::is_recommended_rule(rule_name) {
@@ -166,6 +169,7 @@ impl Rules {
                 .complexity
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if Complexity::is_recommended_rule(rule_name) {
@@ -180,6 +184,7 @@ impl Rules {
                 .correctness
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if Correctness::is_recommended_rule(rule_name) {
@@ -194,6 +199,7 @@ impl Rules {
                 .nursery
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if Nursery::is_recommended_rule(rule_name) {
@@ -208,6 +214,7 @@ impl Rules {
                 .performance
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if Performance::is_recommended_rule(rule_name) {
@@ -222,6 +229,7 @@ impl Rules {
                 .security
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if Security::is_recommended_rule(rule_name) {
@@ -236,6 +244,7 @@ impl Rules {
                 .style
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if Style::is_recommended_rule(rule_name) {
@@ -250,6 +259,7 @@ impl Rules {
                 .suspicious
                 .as_ref()
                 .and_then(|group| group.get_rule_configuration(rule_name))
+                .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                 .map_or_else(
                     || {
                         if Suspicious::is_recommended_rule(rule_name) {
@@ -263,91 +273,6 @@ impl Rules {
         };
         Some(severity)
     }
-    #[doc = r" Set the severity of the rule to its default."]
-    pub fn set_default_severity_if_off(&mut self, group: RuleGroup, rule_name: &str) {
-        match group {
-            RuleGroup::A11y => {
-                if let Some(group) = &mut self.a11y {
-                    let default_severity = if A11y::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-            RuleGroup::Complexity => {
-                if let Some(group) = &mut self.complexity {
-                    let default_severity = if Complexity::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-            RuleGroup::Correctness => {
-                if let Some(group) = &mut self.correctness {
-                    let default_severity = if Correctness::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-            RuleGroup::Nursery => {
-                if let Some(group) = &mut self.nursery {
-                    let default_severity = if Nursery::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-            RuleGroup::Performance => {
-                if let Some(group) = &mut self.performance {
-                    let default_severity = if Performance::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-            RuleGroup::Security => {
-                if let Some(group) = &mut self.security {
-                    let default_severity = if Security::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-            RuleGroup::Style => {
-                if let Some(group) = &mut self.style {
-                    let default_severity = if Style::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-            RuleGroup::Suspicious => {
-                if let Some(group) = &mut self.suspicious {
-                    let default_severity = if Suspicious::is_recommended_rule(rule_name) {
-                        RulePlainConfiguration::Error
-                    } else {
-                        RulePlainConfiguration::Warn
-                    };
-                    group.set_severity_if_off(rule_name, default_severity);
-                }
-            }
-        }
-    }
     #[doc = r" Ensure that `recommended` is set to `true` or implied."]
     pub fn set_recommended(&mut self) {
         if self.all != Some(true) && self.recommended == Some(false) {
@@ -1225,225 +1150,6 @@ impl A11y {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noAccessKey" => {
-                if let Some(rule_conf) = &mut self.no_access_key {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noAriaHiddenOnFocusable" => {
-                if let Some(rule_conf) = &mut self.no_aria_hidden_on_focusable {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noAriaUnsupportedElements" => {
-                if let Some(rule_conf) = &mut self.no_aria_unsupported_elements {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noAutofocus" => {
-                if let Some(rule_conf) = &mut self.no_autofocus {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noBlankTarget" => {
-                if let Some(rule_conf) = &mut self.no_blank_target {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDistractingElements" => {
-                if let Some(rule_conf) = &mut self.no_distracting_elements {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noHeaderScope" => {
-                if let Some(rule_conf) = &mut self.no_header_scope {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noInteractiveElementToNoninteractiveRole" => {
-                if let Some(rule_conf) = &mut self.no_interactive_element_to_noninteractive_role {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNoninteractiveElementToInteractiveRole" => {
-                if let Some(rule_conf) = &mut self.no_noninteractive_element_to_interactive_role {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNoninteractiveTabindex" => {
-                if let Some(rule_conf) = &mut self.no_noninteractive_tabindex {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noPositiveTabindex" => {
-                if let Some(rule_conf) = &mut self.no_positive_tabindex {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noRedundantAlt" => {
-                if let Some(rule_conf) = &mut self.no_redundant_alt {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noRedundantRoles" => {
-                if let Some(rule_conf) = &mut self.no_redundant_roles {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSvgWithoutTitle" => {
-                if let Some(rule_conf) = &mut self.no_svg_without_title {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useAltText" => {
-                if let Some(rule_conf) = &mut self.use_alt_text {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useAnchorContent" => {
-                if let Some(rule_conf) = &mut self.use_anchor_content {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useAriaActivedescendantWithTabindex" => {
-                if let Some(rule_conf) = &mut self.use_aria_activedescendant_with_tabindex {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useAriaPropsForRole" => {
-                if let Some(rule_conf) = &mut self.use_aria_props_for_role {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useButtonType" => {
-                if let Some(rule_conf) = &mut self.use_button_type {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useHeadingContent" => {
-                if let Some(rule_conf) = &mut self.use_heading_content {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useHtmlLang" => {
-                if let Some(rule_conf) = &mut self.use_html_lang {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useIframeTitle" => {
-                if let Some(rule_conf) = &mut self.use_iframe_title {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useKeyWithClickEvents" => {
-                if let Some(rule_conf) = &mut self.use_key_with_click_events {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useKeyWithMouseEvents" => {
-                if let Some(rule_conf) = &mut self.use_key_with_mouse_events {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useMediaCaption" => {
-                if let Some(rule_conf) = &mut self.use_media_caption {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useValidAnchor" => {
-                if let Some(rule_conf) = &mut self.use_valid_anchor {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useValidAriaProps" => {
-                if let Some(rule_conf) = &mut self.use_valid_aria_props {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useValidAriaRole" => {
-                if let Some(rule_conf) = &mut self.use_valid_aria_role {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useValidAriaValues" => {
-                if let Some(rule_conf) = &mut self.use_valid_aria_values {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useValidLang" => {
-                if let Some(rule_conf) = &mut self.use_valid_lang {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[deserializable(with_validator)]
@@ -2152,219 +1858,6 @@ impl Complexity {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noBannedTypes" => {
-                if let Some(rule_conf) = &mut self.no_banned_types {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noEmptyTypeParameters" => {
-                if let Some(rule_conf) = &mut self.no_empty_type_parameters {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noExcessiveCognitiveComplexity" => {
-                if let Some(rule_conf) = &mut self.no_excessive_cognitive_complexity {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noExcessiveNestedTestSuites" => {
-                if let Some(rule_conf) = &mut self.no_excessive_nested_test_suites {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noExtraBooleanCast" => {
-                if let Some(rule_conf) = &mut self.no_extra_boolean_cast {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noForEach" => {
-                if let Some(rule_conf) = &mut self.no_for_each {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noMultipleSpacesInRegularExpressionLiterals" => {
-                if let Some(rule_conf) = &mut self.no_multiple_spaces_in_regular_expression_literals
-                {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noStaticOnlyClass" => {
-                if let Some(rule_conf) = &mut self.no_static_only_class {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noThisInStatic" => {
-                if let Some(rule_conf) = &mut self.no_this_in_static {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessCatch" => {
-                if let Some(rule_conf) = &mut self.no_useless_catch {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessConstructor" => {
-                if let Some(rule_conf) = &mut self.no_useless_constructor {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessEmptyExport" => {
-                if let Some(rule_conf) = &mut self.no_useless_empty_export {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessFragments" => {
-                if let Some(rule_conf) = &mut self.no_useless_fragments {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessLabel" => {
-                if let Some(rule_conf) = &mut self.no_useless_label {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessLoneBlockStatements" => {
-                if let Some(rule_conf) = &mut self.no_useless_lone_block_statements {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessRename" => {
-                if let Some(rule_conf) = &mut self.no_useless_rename {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessSwitchCase" => {
-                if let Some(rule_conf) = &mut self.no_useless_switch_case {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessTernary" => {
-                if let Some(rule_conf) = &mut self.no_useless_ternary {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessThisAlias" => {
-                if let Some(rule_conf) = &mut self.no_useless_this_alias {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessTypeConstraint" => {
-                if let Some(rule_conf) = &mut self.no_useless_type_constraint {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noVoid" => {
-                if let Some(rule_conf) = &mut self.no_void {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noWith" => {
-                if let Some(rule_conf) = &mut self.no_with {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useArrowFunction" => {
-                if let Some(rule_conf) = &mut self.use_arrow_function {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useFlatMap" => {
-                if let Some(rule_conf) = &mut self.use_flat_map {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useLiteralKeys" => {
-                if let Some(rule_conf) = &mut self.use_literal_keys {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useOptionalChain" => {
-                if let Some(rule_conf) = &mut self.use_optional_chain {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useRegexLiterals" => {
-                if let Some(rule_conf) = &mut self.use_regex_literals {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useSimpleNumberKeys" => {
-                if let Some(rule_conf) = &mut self.use_simple_number_keys {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useSimplifiedLogicExpression" => {
-                if let Some(rule_conf) = &mut self.use_simplified_logic_expression {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[deserializable(with_validator)]
@@ -3226,274 +2719,6 @@ impl Correctness {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noChildrenProp" => {
-                if let Some(rule_conf) = &mut self.no_children_prop {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConstAssign" => {
-                if let Some(rule_conf) = &mut self.no_const_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConstantCondition" => {
-                if let Some(rule_conf) = &mut self.no_constant_condition {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConstructorReturn" => {
-                if let Some(rule_conf) = &mut self.no_constructor_return {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noEmptyCharacterClassInRegex" => {
-                if let Some(rule_conf) = &mut self.no_empty_character_class_in_regex {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noEmptyPattern" => {
-                if let Some(rule_conf) = &mut self.no_empty_pattern {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noGlobalObjectCalls" => {
-                if let Some(rule_conf) = &mut self.no_global_object_calls {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noInnerDeclarations" => {
-                if let Some(rule_conf) = &mut self.no_inner_declarations {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noInvalidConstructorSuper" => {
-                if let Some(rule_conf) = &mut self.no_invalid_constructor_super {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noInvalidNewBuiltin" => {
-                if let Some(rule_conf) = &mut self.no_invalid_new_builtin {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noInvalidUseBeforeDeclaration" => {
-                if let Some(rule_conf) = &mut self.no_invalid_use_before_declaration {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNewSymbol" => {
-                if let Some(rule_conf) = &mut self.no_new_symbol {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNonoctalDecimalEscape" => {
-                if let Some(rule_conf) = &mut self.no_nonoctal_decimal_escape {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noPrecisionLoss" => {
-                if let Some(rule_conf) = &mut self.no_precision_loss {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noRenderReturnValue" => {
-                if let Some(rule_conf) = &mut self.no_render_return_value {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSelfAssign" => {
-                if let Some(rule_conf) = &mut self.no_self_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSetterReturn" => {
-                if let Some(rule_conf) = &mut self.no_setter_return {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noStringCaseMismatch" => {
-                if let Some(rule_conf) = &mut self.no_string_case_mismatch {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSwitchDeclarations" => {
-                if let Some(rule_conf) = &mut self.no_switch_declarations {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUndeclaredVariables" => {
-                if let Some(rule_conf) = &mut self.no_undeclared_variables {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnnecessaryContinue" => {
-                if let Some(rule_conf) = &mut self.no_unnecessary_continue {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnreachable" => {
-                if let Some(rule_conf) = &mut self.no_unreachable {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnreachableSuper" => {
-                if let Some(rule_conf) = &mut self.no_unreachable_super {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnsafeFinally" => {
-                if let Some(rule_conf) = &mut self.no_unsafe_finally {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnsafeOptionalChaining" => {
-                if let Some(rule_conf) = &mut self.no_unsafe_optional_chaining {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnusedImports" => {
-                if let Some(rule_conf) = &mut self.no_unused_imports {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnusedLabels" => {
-                if let Some(rule_conf) = &mut self.no_unused_labels {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnusedPrivateClassMembers" => {
-                if let Some(rule_conf) = &mut self.no_unused_private_class_members {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnusedVariables" => {
-                if let Some(rule_conf) = &mut self.no_unused_variables {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noVoidElementsWithChildren" => {
-                if let Some(rule_conf) = &mut self.no_void_elements_with_children {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noVoidTypeReturn" => {
-                if let Some(rule_conf) = &mut self.no_void_type_return {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useExhaustiveDependencies" => {
-                if let Some(rule_conf) = &mut self.use_exhaustive_dependencies {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useHookAtTopLevel" => {
-                if let Some(rule_conf) = &mut self.use_hook_at_top_level {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useIsNan" => {
-                if let Some(rule_conf) = &mut self.use_is_nan {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useJsxKeyInIterable" => {
-                if let Some(rule_conf) = &mut self.use_jsx_key_in_iterable {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useValidForDirection" => {
-                if let Some(rule_conf) = &mut self.use_valid_for_direction {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useYield" => {
-                if let Some(rule_conf) = &mut self.use_yield {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[deserializable(with_validator)]
@@ -4411,302 +3636,6 @@ impl Nursery {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noConsole" => {
-                if let Some(rule_conf) = &mut self.no_console {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConstantMathMinMaxClamp" => {
-                if let Some(rule_conf) = &mut self.no_constant_math_min_max_clamp {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDoneCallback" => {
-                if let Some(rule_conf) = &mut self.no_done_callback {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateAtImportRules" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_at_import_rules {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateElseIf" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_else_if {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateFontNames" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_font_names {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateJsonKeys" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_json_keys {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateSelectorsKeyframeBlock" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_selectors_keyframe_block {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noEmptyBlock" => {
-                if let Some(rule_conf) = &mut self.no_empty_block {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noEvolvingAny" => {
-                if let Some(rule_conf) = &mut self.no_evolving_any {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noFlatMapIdentity" => {
-                if let Some(rule_conf) = &mut self.no_flat_map_identity {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noImportantInKeyframe" => {
-                if let Some(rule_conf) = &mut self.no_important_in_keyframe {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noInvalidPositionAtImportRule" => {
-                if let Some(rule_conf) = &mut self.no_invalid_position_at_import_rule {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noMisplacedAssertion" => {
-                if let Some(rule_conf) = &mut self.no_misplaced_assertion {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNodejsModules" => {
-                if let Some(rule_conf) = &mut self.no_nodejs_modules {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noReactSpecificProps" => {
-                if let Some(rule_conf) = &mut self.no_react_specific_props {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noRestrictedImports" => {
-                if let Some(rule_conf) = &mut self.no_restricted_imports {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUndeclaredDependencies" => {
-                if let Some(rule_conf) = &mut self.no_undeclared_dependencies {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnknownFunction" => {
-                if let Some(rule_conf) = &mut self.no_unknown_function {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnknownMediaFeatureName" => {
-                if let Some(rule_conf) = &mut self.no_unknown_media_feature_name {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnknownProperty" => {
-                if let Some(rule_conf) = &mut self.no_unknown_property {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnknownSelectorPseudoElement" => {
-                if let Some(rule_conf) = &mut self.no_unknown_selector_pseudo_element {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnknownUnit" => {
-                if let Some(rule_conf) = &mut self.no_unknown_unit {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnmatchableAnbSelector" => {
-                if let Some(rule_conf) = &mut self.no_unmatchable_anb_selector {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessStringConcat" => {
-                if let Some(rule_conf) = &mut self.no_useless_string_concat {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessUndefinedInitialization" => {
-                if let Some(rule_conf) = &mut self.no_useless_undefined_initialization {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noYodaExpression" => {
-                if let Some(rule_conf) = &mut self.no_yoda_expression {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useArrayLiterals" => {
-                if let Some(rule_conf) = &mut self.use_array_literals {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useConsistentBuiltinInstantiation" => {
-                if let Some(rule_conf) = &mut self.use_consistent_builtin_instantiation {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useDefaultSwitchClause" => {
-                if let Some(rule_conf) = &mut self.use_default_switch_clause {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useExplicitLengthCheck" => {
-                if let Some(rule_conf) = &mut self.use_explicit_length_check {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useFocusableInteractive" => {
-                if let Some(rule_conf) = &mut self.use_focusable_interactive {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useGenericFontNames" => {
-                if let Some(rule_conf) = &mut self.use_generic_font_names {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useImportExtensions" => {
-                if let Some(rule_conf) = &mut self.use_import_extensions {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useImportRestrictions" => {
-                if let Some(rule_conf) = &mut self.use_import_restrictions {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useNumberToFixedDigitsArgument" => {
-                if let Some(rule_conf) = &mut self.use_number_to_fixed_digits_argument {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useSemanticElements" => {
-                if let Some(rule_conf) = &mut self.use_semantic_elements {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useSortedClasses" => {
-                if let Some(rule_conf) = &mut self.use_sorted_classes {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useThrowNewError" => {
-                if let Some(rule_conf) = &mut self.use_throw_new_error {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useThrowOnlyError" => {
-                if let Some(rule_conf) = &mut self.use_throw_only_error {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useTopLevelRegex" => {
-                if let Some(rule_conf) = &mut self.use_top_level_regex {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[deserializable(with_validator)]
@@ -4880,43 +3809,6 @@ impl Performance {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noAccumulatingSpread" => {
-                if let Some(rule_conf) = &mut self.no_accumulating_spread {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noBarrelFile" => {
-                if let Some(rule_conf) = &mut self.no_barrel_file {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDelete" => {
-                if let Some(rule_conf) = &mut self.no_delete {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noReExportAll" => {
-                if let Some(rule_conf) = &mut self.no_re_export_all {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[deserializable(with_validator)]
@@ -5077,36 +3969,6 @@ impl Security {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noDangerouslySetInnerHtml" => {
-                if let Some(rule_conf) = &mut self.no_dangerously_set_inner_html {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDangerouslySetInnerHtmlWithChildren" => {
-                if let Some(rule_conf) = &mut self.no_dangerously_set_inner_html_with_children {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noGlobalEval" => {
-                if let Some(rule_conf) = &mut self.no_global_eval {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[deserializable(with_validator)]
@@ -6068,316 +4930,6 @@ impl Style {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noArguments" => {
-                if let Some(rule_conf) = &mut self.no_arguments {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noCommaOperator" => {
-                if let Some(rule_conf) = &mut self.no_comma_operator {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDefaultExport" => {
-                if let Some(rule_conf) = &mut self.no_default_export {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noImplicitBoolean" => {
-                if let Some(rule_conf) = &mut self.no_implicit_boolean {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noInferrableTypes" => {
-                if let Some(rule_conf) = &mut self.no_inferrable_types {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNamespace" => {
-                if let Some(rule_conf) = &mut self.no_namespace {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNamespaceImport" => {
-                if let Some(rule_conf) = &mut self.no_namespace_import {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNegationElse" => {
-                if let Some(rule_conf) = &mut self.no_negation_else {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noNonNullAssertion" => {
-                if let Some(rule_conf) = &mut self.no_non_null_assertion {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noParameterAssign" => {
-                if let Some(rule_conf) = &mut self.no_parameter_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noParameterProperties" => {
-                if let Some(rule_conf) = &mut self.no_parameter_properties {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noRestrictedGlobals" => {
-                if let Some(rule_conf) = &mut self.no_restricted_globals {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noShoutyConstants" => {
-                if let Some(rule_conf) = &mut self.no_shouty_constants {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnusedTemplateLiteral" => {
-                if let Some(rule_conf) = &mut self.no_unused_template_literal {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUselessElse" => {
-                if let Some(rule_conf) = &mut self.no_useless_else {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noVar" => {
-                if let Some(rule_conf) = &mut self.no_var {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useAsConstAssertion" => {
-                if let Some(rule_conf) = &mut self.use_as_const_assertion {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useBlockStatements" => {
-                if let Some(rule_conf) = &mut self.use_block_statements {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useCollapsedElseIf" => {
-                if let Some(rule_conf) = &mut self.use_collapsed_else_if {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useConsistentArrayType" => {
-                if let Some(rule_conf) = &mut self.use_consistent_array_type {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useConst" => {
-                if let Some(rule_conf) = &mut self.use_const {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useDefaultParameterLast" => {
-                if let Some(rule_conf) = &mut self.use_default_parameter_last {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useEnumInitializers" => {
-                if let Some(rule_conf) = &mut self.use_enum_initializers {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useExponentiationOperator" => {
-                if let Some(rule_conf) = &mut self.use_exponentiation_operator {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useExportType" => {
-                if let Some(rule_conf) = &mut self.use_export_type {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useFilenamingConvention" => {
-                if let Some(rule_conf) = &mut self.use_filenaming_convention {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useForOf" => {
-                if let Some(rule_conf) = &mut self.use_for_of {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useFragmentSyntax" => {
-                if let Some(rule_conf) = &mut self.use_fragment_syntax {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useImportType" => {
-                if let Some(rule_conf) = &mut self.use_import_type {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useLiteralEnumMembers" => {
-                if let Some(rule_conf) = &mut self.use_literal_enum_members {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useNamingConvention" => {
-                if let Some(rule_conf) = &mut self.use_naming_convention {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useNodeAssertStrict" => {
-                if let Some(rule_conf) = &mut self.use_node_assert_strict {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useNodejsImportProtocol" => {
-                if let Some(rule_conf) = &mut self.use_nodejs_import_protocol {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useNumberNamespace" => {
-                if let Some(rule_conf) = &mut self.use_number_namespace {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useNumericLiterals" => {
-                if let Some(rule_conf) = &mut self.use_numeric_literals {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useSelfClosingElements" => {
-                if let Some(rule_conf) = &mut self.use_self_closing_elements {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useShorthandArrayType" => {
-                if let Some(rule_conf) = &mut self.use_shorthand_array_type {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useShorthandAssign" => {
-                if let Some(rule_conf) = &mut self.use_shorthand_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useShorthandFunctionType" => {
-                if let Some(rule_conf) = &mut self.use_shorthand_function_type {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useSingleCaseStatement" => {
-                if let Some(rule_conf) = &mut self.use_single_case_statement {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useSingleVarDeclarator" => {
-                if let Some(rule_conf) = &mut self.use_single_var_declarator {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useTemplate" => {
-                if let Some(rule_conf) = &mut self.use_template {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useWhile" => {
-                if let Some(rule_conf) = &mut self.use_while {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[deserializable(with_validator)]
@@ -7623,400 +6175,6 @@ impl Suspicious {
             _ => None,
         }
     }
-    pub(crate) fn set_severity_if_off(
-        &mut self,
-        rule_name: &str,
-        severity: RulePlainConfiguration,
-    ) {
-        match rule_name {
-            "noApproximativeNumericConstant" => {
-                if let Some(rule_conf) = &mut self.no_approximative_numeric_constant {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noArrayIndexKey" => {
-                if let Some(rule_conf) = &mut self.no_array_index_key {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noAssignInExpressions" => {
-                if let Some(rule_conf) = &mut self.no_assign_in_expressions {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noAsyncPromiseExecutor" => {
-                if let Some(rule_conf) = &mut self.no_async_promise_executor {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noCatchAssign" => {
-                if let Some(rule_conf) = &mut self.no_catch_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noClassAssign" => {
-                if let Some(rule_conf) = &mut self.no_class_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noCommentText" => {
-                if let Some(rule_conf) = &mut self.no_comment_text {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noCompareNegZero" => {
-                if let Some(rule_conf) = &mut self.no_compare_neg_zero {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConfusingLabels" => {
-                if let Some(rule_conf) = &mut self.no_confusing_labels {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConfusingVoidType" => {
-                if let Some(rule_conf) = &mut self.no_confusing_void_type {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConsoleLog" => {
-                if let Some(rule_conf) = &mut self.no_console_log {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noConstEnum" => {
-                if let Some(rule_conf) = &mut self.no_const_enum {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noControlCharactersInRegex" => {
-                if let Some(rule_conf) = &mut self.no_control_characters_in_regex {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDebugger" => {
-                if let Some(rule_conf) = &mut self.no_debugger {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDoubleEquals" => {
-                if let Some(rule_conf) = &mut self.no_double_equals {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateCase" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_case {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateClassMembers" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_class_members {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateJsxProps" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_jsx_props {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateObjectKeys" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_object_keys {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateParameters" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_parameters {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noDuplicateTestHooks" => {
-                if let Some(rule_conf) = &mut self.no_duplicate_test_hooks {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noEmptyBlockStatements" => {
-                if let Some(rule_conf) = &mut self.no_empty_block_statements {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noEmptyInterface" => {
-                if let Some(rule_conf) = &mut self.no_empty_interface {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noExplicitAny" => {
-                if let Some(rule_conf) = &mut self.no_explicit_any {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noExportsInTest" => {
-                if let Some(rule_conf) = &mut self.no_exports_in_test {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noExtraNonNullAssertion" => {
-                if let Some(rule_conf) = &mut self.no_extra_non_null_assertion {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noFallthroughSwitchClause" => {
-                if let Some(rule_conf) = &mut self.no_fallthrough_switch_clause {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noFocusedTests" => {
-                if let Some(rule_conf) = &mut self.no_focused_tests {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noFunctionAssign" => {
-                if let Some(rule_conf) = &mut self.no_function_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noGlobalAssign" => {
-                if let Some(rule_conf) = &mut self.no_global_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noGlobalIsFinite" => {
-                if let Some(rule_conf) = &mut self.no_global_is_finite {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noGlobalIsNan" => {
-                if let Some(rule_conf) = &mut self.no_global_is_nan {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noImplicitAnyLet" => {
-                if let Some(rule_conf) = &mut self.no_implicit_any_let {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noImportAssign" => {
-                if let Some(rule_conf) = &mut self.no_import_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noLabelVar" => {
-                if let Some(rule_conf) = &mut self.no_label_var {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noMisleadingCharacterClass" => {
-                if let Some(rule_conf) = &mut self.no_misleading_character_class {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noMisleadingInstantiator" => {
-                if let Some(rule_conf) = &mut self.no_misleading_instantiator {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noMisrefactoredShorthandAssign" => {
-                if let Some(rule_conf) = &mut self.no_misrefactored_shorthand_assign {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noPrototypeBuiltins" => {
-                if let Some(rule_conf) = &mut self.no_prototype_builtins {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noRedeclare" => {
-                if let Some(rule_conf) = &mut self.no_redeclare {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noRedundantUseStrict" => {
-                if let Some(rule_conf) = &mut self.no_redundant_use_strict {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSelfCompare" => {
-                if let Some(rule_conf) = &mut self.no_self_compare {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noShadowRestrictedNames" => {
-                if let Some(rule_conf) = &mut self.no_shadow_restricted_names {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSkippedTests" => {
-                if let Some(rule_conf) = &mut self.no_skipped_tests {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSparseArray" => {
-                if let Some(rule_conf) = &mut self.no_sparse_array {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noSuspiciousSemicolonInJsx" => {
-                if let Some(rule_conf) = &mut self.no_suspicious_semicolon_in_jsx {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noThenProperty" => {
-                if let Some(rule_conf) = &mut self.no_then_property {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnsafeDeclarationMerging" => {
-                if let Some(rule_conf) = &mut self.no_unsafe_declaration_merging {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "noUnsafeNegation" => {
-                if let Some(rule_conf) = &mut self.no_unsafe_negation {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useAwait" => {
-                if let Some(rule_conf) = &mut self.use_await {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useDefaultSwitchClauseLast" => {
-                if let Some(rule_conf) = &mut self.use_default_switch_clause_last {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useGetterReturn" => {
-                if let Some(rule_conf) = &mut self.use_getter_return {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useIsArray" => {
-                if let Some(rule_conf) = &mut self.use_is_array {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useNamespaceKeyword" => {
-                if let Some(rule_conf) = &mut self.use_namespace_keyword {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            "useValidTypeof" => {
-                if let Some(rule_conf) = &mut self.use_valid_typeof {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
 }
 #[test]
 fn test_order() {
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
index 3fb37f731550..b86f27bf56d9 100644
--- a/crates/biome_service/src/file_handlers/css.rs
+++ b/crates/biome_service/src/file_handlers/css.rs
@@ -3,7 +3,7 @@ use super::{
     LintResults, ParseResult,
 };
 use crate::configuration::to_analyzer_rules;
-use crate::file_handlers::{only_rules, DebugCapabilities};
+use crate::file_handlers::DebugCapabilities;
 use crate::file_handlers::{
     AnalyzerCapabilities, Capabilities, FormatterCapabilities, ParserCapabilities,
 };
@@ -329,19 +329,23 @@ fn lint(params: LintParams) -> LintResults {
             let mut diagnostics = params.parse.into_diagnostics();
 
             // Compute final rules (taking `overrides` into account)
-            let mut rules = settings.as_rules(params.path.as_path());
+            let rules = settings.as_rules(params.path.as_path());
 
-            let enabled_rules = if params.only.is_empty() {
+            let has_only_filter = !params.only.is_empty();
+            let enabled_rules = if has_only_filter {
+                params
+                    .only
+                    .into_iter()
+                    .map(|selector| selector.into())
+                    .collect::<Vec<_>>()
+            } else {
                 rules
                     .as_ref()
                     .map(|rules| rules.as_enabled_rules())
                     .unwrap_or_default()
-            } else {
-                // Filter rule/groups according to the `--only` and `--skip` options.
-                // `--only` and `--skip` behave like `--include`/`--ignore`
-                only_rules(&mut rules, &params.only)
+                    .into_iter()
+                    .collect::<Vec<_>>()
             };
-            let enabled_rules = enabled_rules.into_iter().collect::<Vec<_>>();
             let disabled_rules = params
                 .skip
                 .into_iter()
@@ -354,18 +358,18 @@ fn lint(params: LintParams) -> LintResults {
                 range: None,
             };
 
+            // Do not report unused suppression comment diagnostics if:
+            // - 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;
+
             let mut diagnostic_count = diagnostics.len() as u32;
             let mut errors = diagnostics
                 .iter()
                 .filter(|diag| diag.severity() <= Severity::Error)
                 .count();
 
-            // Do not report unused suppression comment diagnostics if:
-            // - it is a syntax-only analyzer pass, or
-            // - if a single rule is run.
-            let ignores_suppression_comment =
-                !filter.categories.contains(RuleCategories::LINT) || !params.only.is_empty();
-
             info!("Analyze file {}", params.path.display());
             let (_, analyze_diagnostics) = analyze(&tree, filter, &analyzer_options, |signal| {
                 if let Some(mut diagnostic) = signal.diagnostic() {
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
index 4c9d5e15d6f0..d1e9cbbb6d93 100644
--- a/crates/biome_service/src/file_handlers/javascript.rs
+++ b/crates/biome_service/src/file_handlers/javascript.rs
@@ -4,7 +4,7 @@ use super::{
 };
 use crate::configuration::to_analyzer_rules;
 use crate::diagnostics::extension_error;
-use crate::file_handlers::{is_diagnostic_error, only_rules, FixAllParams};
+use crate::file_handlers::{is_diagnostic_error, FixAllParams};
 use crate::settings::{LinterSettings, OverrideSettings, Settings};
 use crate::workspace::{DocumentFileSource, OrganizeImportsResult};
 use crate::{
@@ -376,9 +376,16 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
                 .analyzer_options::<JsLanguage>(params.path, &params.language);
 
             // Compute final rules (taking `overrides` into account)
-            let mut rules = settings.as_rules(params.path.as_path());
+            let rules = settings.as_rules(params.path.as_path());
 
-            let enabled_rules = if params.only.is_empty() {
+            let has_only_filter = !params.only.is_empty();
+            let enabled_rules = if has_only_filter {
+                params
+                    .only
+                    .into_iter()
+                    .map(|selector| selector.into())
+                    .collect::<Vec<_>>()
+            } else {
                 let mut rule_filter_list = rules
                     .as_ref()
                     .map(|rules| rules.as_enabled_rules())
@@ -396,10 +403,6 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
                 rule_filter_list.push(RuleFilter::Rule("correctness", "noSuperWithoutExtends"));
                 rule_filter_list.push(RuleFilter::Rule("nursery", "noSuperWithoutExtends"));
                 rule_filter_list
-            } else {
-                // Filter rule/groups according to the `--only` and `--skip` options.
-                // `--only` and `--skip` behave like `--include`/`--ignore`
-                only_rules(&mut rules, &params.only).into_iter().collect()
             };
             let disabled_rules = params
                 .skip
@@ -413,18 +416,18 @@ pub(crate) fn lint(params: LintParams) -> LintResults {
                 range: None,
             };
 
+            // Do not report unused suppression comment diagnostics if:
+            // - 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;
+
             let mut diagnostic_count = diagnostics.len() as u32;
             let mut errors = diagnostics
                 .iter()
                 .filter(|diag| diag.severity() <= Severity::Error)
                 .count();
 
-            // Do not report unused suppression comment diagnostics if:
-            // - it is a syntax-only analyzer pass, or
-            // - if a single rule is run.
-            let ignores_suppression_comment =
-                !filter.categories.contains(RuleCategories::LINT) || !params.only.is_empty();
-
             info!("Analyze file {}", params.path.display());
             let (_, analyze_diagnostics) = analyze(
                 &tree,
diff --git a/crates/biome_service/src/file_handlers/json.rs b/crates/biome_service/src/file_handlers/json.rs
index db8678dfb136..200656e188a9 100644
--- a/crates/biome_service/src/file_handlers/json.rs
+++ b/crates/biome_service/src/file_handlers/json.rs
@@ -1,4 +1,4 @@
-use super::{only_rules, CodeActionsParams, DocumentFileSource, ExtensionHandler, ParseResult};
+use super::{CodeActionsParams, DocumentFileSource, ExtensionHandler, ParseResult};
 use crate::configuration::to_analyzer_rules;
 use crate::file_handlers::DebugCapabilities;
 use crate::file_handlers::{
@@ -307,30 +307,27 @@ fn lint(params: LintParams) -> LintResults {
                 );
             }
 
-            let mut diagnostic_count = diagnostics.len() as u32;
-            let mut errors = diagnostics
-                .iter()
-                .filter(|diag| diag.severity() <= Severity::Error)
-                .count();
-
-            let skipped_diagnostics = diagnostic_count - diagnostics.len() as u32;
-
             let analyzer_options = &params
                 .settings
                 .analyzer_options::<JsonLanguage>(params.path, &params.language);
 
-            let mut rules = settings.as_rules(params.path.as_path());
-            let enabled_rules = if params.only.is_empty() {
+            let rules = settings.as_rules(params.path.as_path());
+
+            let has_only_filter = !params.only.is_empty();
+            let enabled_rules = if has_only_filter {
+                params
+                    .only
+                    .into_iter()
+                    .map(|selector| selector.into())
+                    .collect::<Vec<_>>()
+            } else {
                 rules
                     .as_ref()
                     .map(|rules| rules.as_enabled_rules())
                     .unwrap_or_default()
-            } else {
-                // Filter rule/groups according to the `--only` and `--skip` options.
-                // `--only` and `--skip` behave like `--include`/`--ignore`
-                only_rules(&mut rules, &params.only)
+                    .into_iter()
+                    .collect::<Vec<_>>()
             };
-            let enabled_rules = enabled_rules.into_iter().collect::<Vec<_>>();
             let disabled_rules = params
                 .skip
                 .into_iter()
@@ -347,7 +344,14 @@ 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) || !params.only.is_empty();
+                !filter.categories.contains(RuleCategories::LINT) || has_only_filter;
+
+            let mut diagnostic_count = diagnostics.len() as u32;
+            let mut errors = diagnostics
+                .iter()
+                .filter(|diag| diag.severity() <= Severity::Error)
+                .count();
+            let skipped_diagnostics = diagnostic_count - diagnostics.len() as u32;
 
             let (_, analyze_diagnostics) = analyze(&root, filter, analyzer_options, |signal| {
                 if let Some(mut diagnostic) = signal.diagnostic() {
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
index 59c22df66a92..4e110b9abf88 100644
--- a/crates/biome_service/src/file_handlers/mod.rs
+++ b/crates/biome_service/src/file_handlers/mod.rs
@@ -11,7 +11,7 @@ use crate::{
     workspace::{FixFileResult, GetSyntaxTreeResult, PullActionsResult, RenameResult},
     WorkspaceError,
 };
-use biome_analyze::{AnalysisFilter, AnalyzerDiagnostic, RuleCategories, RuleFilter};
+use biome_analyze::{AnalysisFilter, AnalyzerDiagnostic, RuleCategories};
 use biome_configuration::linter::RuleSelector;
 use biome_configuration::Rules;
 use biome_console::fmt::Formatter;
@@ -27,8 +27,6 @@ use biome_parser::AnyParse;
 use biome_project::PackageJson;
 use biome_rowan::{FileSourceError, NodeCache};
 pub use javascript::JsFormatterSettings;
-use rustc_hash::FxHashSet;
-use std::borrow::Cow;
 use std::ffi::OsStr;
 use std::path::Path;
 
@@ -552,46 +550,6 @@ pub(crate) fn parse_lang_from_script_opening_tag(script_opening_tag: &str) -> La
     .map_or(Language::JavaScript, |lang| lang)
 }
 
-/// Returns the rules enabled in `rules` and filtered by `only` and `skip`.
-pub(crate) fn only_rules(
-    rules: &mut Option<Cow<Rules>>,
-    only: &[RuleSelector],
-) -> FxHashSet<RuleFilter<'static>> {
-    let mut enabled_rules = rustc_hash::FxHashSet::<RuleFilter>::default();
-    let mut only_groups = rustc_hash::FxHashSet::default();
-    for selector in only {
-        match selector {
-            RuleSelector::Group(group) => {
-                only_groups.insert(group.as_str());
-            }
-            RuleSelector::Rule(group, rule_name) => {
-                if let Some(rules) = rules.as_mut() {
-                    // Set the severity level of the rule to its default.
-                    rules
-                        .to_mut()
-                        .set_default_severity_if_off(*group, rule_name);
-                }
-                enabled_rules.insert((*selector).into());
-            }
-        }
-    }
-    if !only_groups.is_empty() {
-        if let Some(rules) = rules.as_mut() {
-            // Ensure that the recommended field is not set to `false`.
-            rules.to_mut().set_recommended();
-        }
-        enabled_rules.extend(
-            rules
-                .as_ref()
-                .map(|rules| rules.as_enabled_rules())
-                .unwrap_or_default()
-                .into_iter()
-                .filter(|rule_filter| only_groups.contains(&rule_filter.group())),
-        );
-    }
-    enabled_rules
-}
-
 #[test]
 fn test_svelte_script_lang() {
     const SVELTE_JS_SCRIPT_OPENING_TAG: &str = r#"<script>"#;
diff --git a/xtask/codegen/src/generate_configuration.rs b/xtask/codegen/src/generate_configuration.rs
index 5849ef2e7df8..225eded5b695 100644
--- a/xtask/codegen/src/generate_configuration.rs
+++ b/xtask/codegen/src/generate_configuration.rs
@@ -228,6 +228,8 @@ pub(crate) fn generate_rules_configuration(mode: Mode) -> Result<()> {
 
             /// Given a category coming from [Diagnostic](biome_diagnostics::Diagnostic), this function returns
             /// the [Severity](biome_diagnostics::Severity) associated to the rule, if the configuration changed it.
+            /// If the severity is off or not set, then the function returns the default severity of the rule:
+            /// [Severity::Error] for recommended rules and [Severity::Warning] for other rules.
             ///
             /// If not, the function returns [None].
             pub fn get_severity_from_code(&self, category: &Category) -> Option<Severity> {
@@ -245,6 +247,7 @@ pub(crate) fn generate_rules_configuration(mode: Mode) -> Result<()> {
                             .#group_idents
                             .as_ref()
                             .and_then(|group| group.get_rule_configuration(rule_name))
+                            .filter(|(level, _)| !matches!(level, RulePlainConfiguration::Off))
                             .map_or_else(|| {
                                 if #group_pascal_idents::is_recommended_rule(rule_name) {
                                     Severity::Error
@@ -257,24 +260,6 @@ pub(crate) fn generate_rules_configuration(mode: Mode) -> Result<()> {
                 Some(severity)
             }
 
-            /// Set the severity of the rule to its default if its severity if set to `off`.
-            pub fn set_default_severity_if_off(&mut self, group: RuleGroup, rule_name: &str) {
-                match group {
-                    #(
-                        RuleGroup::#group_pascal_idents => {
-                            if let Some(group) = &mut self.#group_idents {
-                                let default_severity = if #group_pascal_idents::is_recommended_rule(rule_name) {
-                                    RulePlainConfiguration::Error
-                                } else {
-                                    RulePlainConfiguration::Warn
-                                };
-                                group.set_severity_if_off(rule_name, default_severity);
-                            }
-                        }
-                    )*
-                }
-            }
-
             /// Ensure that `recommended` is set to `true` or implied.
             pub fn set_recommended(&mut self) {
                 if self.all != Some(true) && self.recommended == Some(false) {
@@ -372,7 +357,6 @@ fn generate_struct(group: &str, rules: &BTreeMap<&'static str, RuleMetadata>) ->
     let mut rule_enabled_check_line = Vec::new();
     let mut rule_disabled_check_line = Vec::new();
     let mut get_rule_configuration_line = Vec::new();
-    let mut set_severity_if_off = Vec::new();
 
     for (index, (rule, metadata)) in rules.iter().enumerate() {
         let summary = {
@@ -475,15 +459,6 @@ fn generate_struct(group: &str, rules: &BTreeMap<&'static str, RuleMetadata>) ->
         get_rule_configuration_line.push(quote! {
             #rule => self.#rule_identifier.as_ref().map(|conf| (conf.level(), conf.get_options()))
         });
-        set_severity_if_off.push(quote! {
-            #rule => {
-                if let Some(rule_conf) = &mut self.#rule_identifier {
-                    if matches!(rule_conf.level(), RulePlainConfiguration::Off) {
-                        rule_conf.set_level(severity);
-                    }
-                }
-            }
-        });
     }
 
     let group_pascal_ident = Ident::new(&to_capitalized(group), Span::call_site());
@@ -617,13 +592,6 @@ fn generate_struct(group: &str, rules: &BTreeMap<&'static str, RuleMetadata>) ->
                     _ => None
                 }
             }
-
-            pub(crate) fn set_severity_if_off(&mut self, rule_name: &str, severity: RulePlainConfiguration) {
-                match rule_name {
-                    #( #set_severity_if_off ),*
-                    _ => {}
-                }
-            }
         }
     }
 }