Repository: biomejs/biome (language: rust)

Issue:
BREAKING: Remove deprecated rules
- `noInvalidNewBuiltin`
- `noNewSymbol`
-  `useShorthandArrayType`
-  `useSingleCaseStatement`
-  `noConsoleLog`


Discussion / hints:

Fix patch:
diff --git a/.changeset/remove_deprecaterd_rules.md b/.changeset/remove_deprecaterd_rules.md
new file mode 100644
index 000000000000..d98084f10a46
--- /dev/null
+++ b/.changeset/remove_deprecaterd_rules.md
@@ -0,0 +1,15 @@
+---
+cli: major
+---
+
+# Remove deprecated rules
+
+The following _deprecated_ rules have been deleted:
+
+- `noInvalidNewBuiltin`
+- `noNewSymbol`
+- `useShorthandArrayType`
+- `useSingleCaseStatement`
+- `noConsoleLog`
+
+Run the command `biome migrate --write` to update the configuration.
diff --git a/.changeset/the_rule_noconsolelog_has_been_removed.md b/.changeset/the_rule_noconsolelog_has_been_removed.md
new file mode 100644
index 000000000000..0673d8afe202
--- /dev/null
+++ b/.changeset/the_rule_noconsolelog_has_been_removed.md
@@ -0,0 +1,5 @@
+---
+cli: major
+---
+
+# The rule `noConsoleLog` has been removed
diff --git a/crates/biome_configuration/src/analyzer/linter/rules.rs b/crates/biome_configuration/src/analyzer/linter/rules.rs
index dae89252d0dd..315499a27ce1 100644
--- a/crates/biome_configuration/src/analyzer/linter/rules.rs
+++ b/crates/biome_configuration/src/analyzer/linter/rules.rs
@@ -5292,9 +5292,6 @@ pub struct Suspicious {
     #[doc = "Disallow the use of console."]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub no_console: Option<RuleFixConfiguration<biome_js_analyze::options::NoConsole>>,
-    #[doc = "Disallow the use of console.log"]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub no_console_log: Option<RuleFixConfiguration<biome_js_analyze::options::NoConsoleLog>>,
     #[doc = "Disallow TypeScript const enum"]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub no_const_enum: Option<RuleFixConfiguration<biome_js_analyze::options::NoConstEnum>>,
@@ -5508,7 +5505,6 @@ impl Suspicious {
         "noConfusingLabels",
         "noConfusingVoidType",
         "noConsole",
-        "noConsoleLog",
         "noConstEnum",
         "noControlCharactersInRegex",
         "noDebugger",
@@ -5577,6 +5573,7 @@ impl Suspicious {
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[7]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[8]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[9]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[11]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[12]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[13]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[14]),
@@ -5590,8 +5587,8 @@ impl Suspicious {
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[22]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[23]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[24]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[27]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[26]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]),
@@ -5606,24 +5603,23 @@ impl Suspicious {
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[40]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[41]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[42]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[43]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[44]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[45]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[46]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[47]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[48]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[49]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[50]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[51]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[52]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[53]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[54]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[55]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[56]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[57]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[58]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[61]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[60]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[62]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[63]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[64]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[65]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[67]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[66]),
     ];
     #[doc = r" Retrieves the recommended rules"]
     pub(crate) fn is_recommended_true(&self) -> bool {
@@ -5689,289 +5685,284 @@ impl Suspicious {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[10]));
             }
         }
-        if let Some(rule) = self.no_console_log.as_ref() {
-            if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[11]));
-            }
-        }
         if let Some(rule) = self.no_const_enum.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[12]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[11]));
             }
         }
         if let Some(rule) = self.no_control_characters_in_regex.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[13]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[12]));
             }
         }
         if let Some(rule) = self.no_debugger.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[14]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[13]));
             }
         }
         if let Some(rule) = self.no_double_equals.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[15]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[14]));
             }
         }
         if let Some(rule) = self.no_duplicate_at_import_rules.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[16]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[15]));
             }
         }
         if let Some(rule) = self.no_duplicate_case.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[17]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[16]));
             }
         }
         if let Some(rule) = self.no_duplicate_class_members.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[18]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[17]));
             }
         }
         if let Some(rule) = self.no_duplicate_font_names.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[19]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[18]));
             }
         }
         if let Some(rule) = self.no_duplicate_jsx_props.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[20]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[19]));
             }
         }
         if let Some(rule) = self.no_duplicate_object_keys.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[21]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[20]));
             }
         }
         if let Some(rule) = self.no_duplicate_parameters.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[22]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[21]));
             }
         }
         if let Some(rule) = self.no_duplicate_selectors_keyframe_block.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[23]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[22]));
             }
         }
         if let Some(rule) = self.no_duplicate_test_hooks.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[24]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[23]));
             }
         }
         if let Some(rule) = self.no_empty_block.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[24]));
             }
         }
         if let Some(rule) = self.no_empty_block_statements.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[26]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]));
             }
         }
         if let Some(rule) = self.no_empty_interface.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[27]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[26]));
             }
         }
         if let Some(rule) = self.no_evolving_types.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[27]));
             }
         }
         if let Some(rule) = self.no_explicit_any.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]));
             }
         }
         if let Some(rule) = self.no_exports_in_test.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]));
             }
         }
         if let Some(rule) = self.no_extra_non_null_assertion.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]));
             }
         }
         if let Some(rule) = self.no_fallthrough_switch_clause.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[32]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]));
             }
         }
         if let Some(rule) = self.no_focused_tests.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[33]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[32]));
             }
         }
         if let Some(rule) = self.no_function_assign.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[34]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[33]));
             }
         }
         if let Some(rule) = self.no_global_assign.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[35]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[34]));
             }
         }
         if let Some(rule) = self.no_global_is_finite.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[36]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[35]));
             }
         }
         if let Some(rule) = self.no_global_is_nan.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[37]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[36]));
             }
         }
         if let Some(rule) = self.no_implicit_any_let.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[38]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[37]));
             }
         }
         if let Some(rule) = self.no_import_assign.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[39]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[38]));
             }
         }
         if let Some(rule) = self.no_important_in_keyframe.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[40]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[39]));
             }
         }
         if let Some(rule) = self.no_label_var.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[41]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[40]));
             }
         }
         if let Some(rule) = self.no_misleading_character_class.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[42]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[41]));
             }
         }
         if let Some(rule) = self.no_misleading_instantiator.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[43]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[42]));
             }
         }
         if let Some(rule) = self.no_misplaced_assertion.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[44]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[43]));
             }
         }
         if let Some(rule) = self.no_misrefactored_shorthand_assign.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[45]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[44]));
             }
         }
         if let Some(rule) = self.no_prototype_builtins.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[46]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[45]));
             }
         }
         if let Some(rule) = self.no_react_specific_props.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[47]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[46]));
             }
         }
         if let Some(rule) = self.no_redeclare.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[48]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[47]));
             }
         }
         if let Some(rule) = self.no_redundant_use_strict.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[49]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[48]));
             }
         }
         if let Some(rule) = self.no_self_compare.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[50]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[49]));
             }
         }
         if let Some(rule) = self.no_shadow_restricted_names.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[51]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[50]));
             }
         }
         if let Some(rule) = self.no_shorthand_property_overrides.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[52]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[51]));
             }
         }
         if let Some(rule) = self.no_skipped_tests.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[53]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[52]));
             }
         }
         if let Some(rule) = self.no_sparse_array.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[54]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[53]));
             }
         }
         if let Some(rule) = self.no_suspicious_semicolon_in_jsx.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[55]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[54]));
             }
         }
         if let Some(rule) = self.no_then_property.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[56]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[55]));
             }
         }
         if let Some(rule) = self.no_unsafe_declaration_merging.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[57]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[56]));
             }
         }
         if let Some(rule) = self.no_unsafe_negation.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[58]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[57]));
             }
         }
         if let Some(rule) = self.no_var.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[59]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[58]));
             }
         }
         if let Some(rule) = self.use_await.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[60]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[59]));
             }
         }
         if let Some(rule) = self.use_default_switch_clause_last.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[61]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[60]));
             }
         }
         if let Some(rule) = self.use_error_message.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[62]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[61]));
             }
         }
         if let Some(rule) = self.use_getter_return.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[63]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[62]));
             }
         }
         if let Some(rule) = self.use_is_array.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[64]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[63]));
             }
         }
         if let Some(rule) = self.use_namespace_keyword.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[65]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[64]));
             }
         }
         if let Some(rule) = self.use_number_to_fixed_digits_argument.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[66]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[65]));
             }
         }
         if let Some(rule) = self.use_valid_typeof.as_ref() {
             if rule.is_enabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[67]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[66]));
             }
         }
         index_set
@@ -6033,289 +6024,284 @@ impl Suspicious {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[10]));
             }
         }
-        if let Some(rule) = self.no_console_log.as_ref() {
-            if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[11]));
-            }
-        }
         if let Some(rule) = self.no_const_enum.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[12]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[11]));
             }
         }
         if let Some(rule) = self.no_control_characters_in_regex.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[13]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[12]));
             }
         }
         if let Some(rule) = self.no_debugger.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[14]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[13]));
             }
         }
         if let Some(rule) = self.no_double_equals.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[15]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[14]));
             }
         }
         if let Some(rule) = self.no_duplicate_at_import_rules.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[16]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[15]));
             }
         }
         if let Some(rule) = self.no_duplicate_case.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[17]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[16]));
             }
         }
         if let Some(rule) = self.no_duplicate_class_members.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[18]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[17]));
             }
         }
         if let Some(rule) = self.no_duplicate_font_names.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[19]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[18]));
             }
         }
         if let Some(rule) = self.no_duplicate_jsx_props.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[20]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[19]));
             }
         }
         if let Some(rule) = self.no_duplicate_object_keys.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[21]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[20]));
             }
         }
         if let Some(rule) = self.no_duplicate_parameters.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[22]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[21]));
             }
         }
         if let Some(rule) = self.no_duplicate_selectors_keyframe_block.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[23]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[22]));
             }
         }
         if let Some(rule) = self.no_duplicate_test_hooks.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[24]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[23]));
             }
         }
         if let Some(rule) = self.no_empty_block.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[24]));
             }
         }
         if let Some(rule) = self.no_empty_block_statements.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[26]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]));
             }
         }
         if let Some(rule) = self.no_empty_interface.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[27]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[26]));
             }
         }
         if let Some(rule) = self.no_evolving_types.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[27]));
             }
         }
         if let Some(rule) = self.no_explicit_any.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]));
             }
         }
         if let Some(rule) = self.no_exports_in_test.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]));
             }
         }
         if let Some(rule) = self.no_extra_non_null_assertion.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]));
             }
         }
         if let Some(rule) = self.no_fallthrough_switch_clause.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[32]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]));
             }
         }
         if let Some(rule) = self.no_focused_tests.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[33]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[32]));
             }
         }
         if let Some(rule) = self.no_function_assign.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[34]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[33]));
             }
         }
         if let Some(rule) = self.no_global_assign.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[35]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[34]));
             }
         }
         if let Some(rule) = self.no_global_is_finite.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[36]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[35]));
             }
         }
         if let Some(rule) = self.no_global_is_nan.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[37]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[36]));
             }
         }
         if let Some(rule) = self.no_implicit_any_let.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[38]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[37]));
             }
         }
         if let Some(rule) = self.no_import_assign.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[39]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[38]));
             }
         }
         if let Some(rule) = self.no_important_in_keyframe.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[40]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[39]));
             }
         }
         if let Some(rule) = self.no_label_var.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[41]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[40]));
             }
         }
         if let Some(rule) = self.no_misleading_character_class.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[42]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[41]));
             }
         }
         if let Some(rule) = self.no_misleading_instantiator.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[43]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[42]));
             }
         }
         if let Some(rule) = self.no_misplaced_assertion.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[44]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[43]));
             }
         }
         if let Some(rule) = self.no_misrefactored_shorthand_assign.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[45]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[44]));
             }
         }
         if let Some(rule) = self.no_prototype_builtins.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[46]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[45]));
             }
         }
         if let Some(rule) = self.no_react_specific_props.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[47]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[46]));
             }
         }
         if let Some(rule) = self.no_redeclare.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[48]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[47]));
             }
         }
         if let Some(rule) = self.no_redundant_use_strict.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[49]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[48]));
             }
         }
         if let Some(rule) = self.no_self_compare.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[50]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[49]));
             }
         }
         if let Some(rule) = self.no_shadow_restricted_names.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[51]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[50]));
             }
         }
         if let Some(rule) = self.no_shorthand_property_overrides.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[52]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[51]));
             }
         }
         if let Some(rule) = self.no_skipped_tests.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[53]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[52]));
             }
         }
         if let Some(rule) = self.no_sparse_array.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[54]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[53]));
             }
         }
         if let Some(rule) = self.no_suspicious_semicolon_in_jsx.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[55]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[54]));
             }
         }
         if let Some(rule) = self.no_then_property.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[56]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[55]));
             }
         }
         if let Some(rule) = self.no_unsafe_declaration_merging.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[57]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[56]));
             }
         }
         if let Some(rule) = self.no_unsafe_negation.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[58]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[57]));
             }
         }
         if let Some(rule) = self.no_var.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[59]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[58]));
             }
         }
         if let Some(rule) = self.use_await.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[60]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[59]));
             }
         }
         if let Some(rule) = self.use_default_switch_clause_last.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[61]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[60]));
             }
         }
         if let Some(rule) = self.use_error_message.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[62]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[61]));
             }
         }
         if let Some(rule) = self.use_getter_return.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[63]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[62]));
             }
         }
         if let Some(rule) = self.use_is_array.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[64]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[63]));
             }
         }
         if let Some(rule) = self.use_namespace_keyword.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[65]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[64]));
             }
         }
         if let Some(rule) = self.use_number_to_fixed_digits_argument.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[66]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[65]));
             }
         }
         if let Some(rule) = self.use_valid_typeof.as_ref() {
             if rule.is_disabled() {
-                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[67]));
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[66]));
             }
         }
         index_set
@@ -6386,10 +6372,6 @@ impl Suspicious {
                 .no_console
                 .as_ref()
                 .map(|conf| (conf.level(), conf.get_options())),
-            "noConsoleLog" => self
-                .no_console_log
-                .as_ref()
-                .map(|conf| (conf.level(), conf.get_options())),
             "noConstEnum" => self
                 .no_const_enum
                 .as_ref()
diff --git a/crates/biome_diagnostics_categories/src/categories.rs b/crates/biome_diagnostics_categories/src/categories.rs
index 4467764824a6..c27f7c3057cb 100644
--- a/crates/biome_diagnostics_categories/src/categories.rs
+++ b/crates/biome_diagnostics_categories/src/categories.rs
@@ -283,7 +283,6 @@ define_categories! {
     "lint/suspicious/noConfusingLabels": "https://biomejs.dev/linter/rules/no-confusing-labels",
     "lint/suspicious/noConfusingVoidType": "https://biomejs.dev/linter/rules/no-confusing-void-type",
     "lint/suspicious/noConsole": "https://biomejs.dev/linter/rules/no-console",
-    "lint/suspicious/noConsoleLog": "https://biomejs.dev/linter/rules/no-console-log",
     "lint/suspicious/noConstEnum": "https://biomejs.dev/linter/rules/no-const-enum",
     "lint/suspicious/noControlCharactersInRegex": "https://biomejs.dev/linter/rules/no-control-characters-in-regex",
     "lint/suspicious/noDebugger": "https://biomejs.dev/linter/rules/no-debugger",
diff --git a/crates/biome_js_analyze/src/lint/suspicious.rs b/crates/biome_js_analyze/src/lint/suspicious.rs
index 8f0886ac1971..a29e38cb945e 100644
--- a/crates/biome_js_analyze/src/lint/suspicious.rs
+++ b/crates/biome_js_analyze/src/lint/suspicious.rs
@@ -13,7 +13,6 @@ pub mod no_compare_neg_zero;
 pub mod no_confusing_labels;
 pub mod no_confusing_void_type;
 pub mod no_console;
-pub mod no_console_log;
 pub mod no_const_enum;
 pub mod no_control_characters_in_regex;
 pub mod no_debugger;
@@ -80,7 +79,6 @@ declare_lint_group! {
             self :: no_confusing_labels :: NoConfusingLabels ,
             self :: no_confusing_void_type :: NoConfusingVoidType ,
             self :: no_console :: NoConsole ,
-            self :: no_console_log :: NoConsoleLog ,
             self :: no_const_enum :: NoConstEnum ,
             self :: no_control_characters_in_regex :: NoControlCharactersInRegex ,
             self :: no_debugger :: NoDebugger ,
diff --git a/crates/biome_js_analyze/src/lint/suspicious/no_console_log.rs b/crates/biome_js_analyze/src/lint/suspicious/no_console_log.rs
deleted file mode 100644
index 9f8f0615ce92..000000000000
--- a/crates/biome_js_analyze/src/lint/suspicious/no_console_log.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use crate::{services::semantic::Semantic, JsRuleAction};
-use biome_analyze::{context::RuleContext, declare_lint_rule, FixKind, Rule, RuleDiagnostic};
-use biome_console::markup;
-use biome_js_syntax::{
-    global_identifier, AnyJsMemberExpression, JsCallExpression, JsExpressionStatement,
-};
-use biome_rowan::{AstNode, BatchMutationExt};
-
-declare_lint_rule! {
-    /// Disallow the use of `console.log`
-    ///
-    /// ## Examples
-    ///
-    /// ### Invalid
-    ///
-    /// ```js,expect_diagnostic
-    /// console.log()
-    /// ```
-    ///
-    /// ### Valid
-    ///
-    /// ```js
-    /// console.info("info");
-    /// console.warn("warn");
-    /// console.error("error");
-    /// console.assert(true);
-    /// console.table(["foo", "bar"]);
-    /// const console = { log() {} };
-    /// console.log();
-    /// ```
-    ///
-    pub NoConsoleLog {
-        version: "1.0.0",
-        name: "noConsoleLog",
-        language: "js",
-        recommended: false,
-        deprecated: "Use the rule noConsole instead.",
-        fix_kind: FixKind::Unsafe,
-    }
-}
-
-impl Rule for NoConsoleLog {
-    type Query = Semantic<JsCallExpression>;
-    type State = ();
-    type Signals = Option<Self::State>;
-    type Options = ();
-
-    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
-        let call_expression = ctx.query();
-        let model = ctx.model();
-        let callee = call_expression.callee().ok()?;
-        let member_expression = AnyJsMemberExpression::cast(callee.into_syntax())?;
-        if member_expression.member_name()?.text() != "log" {
-            return None;
-        }
-        let object = member_expression.object().ok()?;
-        let (reference, name) = global_identifier(&object)?;
-        if name.text() != "console" {
-            return None;
-        }
-        model.binding(&reference).is_none().then_some(())
-    }
-
-    fn diagnostic(ctx: &RuleContext<Self>, _: &Self::State) -> Option<RuleDiagnostic> {
-        let node = ctx.query();
-        let node = JsExpressionStatement::cast(node.syntax().parent()?)?;
-        Some(
-            RuleDiagnostic::new(
-                rule_category!(),
-                node.syntax().text_trimmed_range(),
-                markup! {
-                    "Don't use "<Emphasis>"console.log"</Emphasis>
-                },
-            )
-            .note(markup! {
-                <Emphasis>"console.log"</Emphasis>" is usually a tool for debugging and you don't want to have that in production."
-            })
-            .note(markup! {
-                "If it is not for debugging purpose then using "<Emphasis>"console.info"</Emphasis>" might be more appropriate."
-            }),
-        )
-    }
-
-    fn action(ctx: &RuleContext<Self>, _: &Self::State) -> Option<JsRuleAction> {
-        let call_expression = ctx.query();
-        let mut mutation = ctx.root().begin();
-
-        match JsExpressionStatement::cast(call_expression.syntax().parent()?) {
-            Some(stmt) if stmt.semicolon_token().is_some() => {
-                mutation.remove_node(stmt);
-            }
-            _ => {
-                mutation.remove_node(call_expression.clone());
-            }
-        }
-
-        Some(JsRuleAction::new(
-            ctx.metadata().action_category(ctx.category(), ctx.group()),
-            ctx.metadata().applicability(),
-            markup! { "Remove console.log" }.to_owned(),
-            mutation,
-        ))
-    }
-}
diff --git a/crates/biome_js_analyze/src/options.rs b/crates/biome_js_analyze/src/options.rs
index 99d8c55e8dcc..ef6744be0176 100644
--- a/crates/biome_js_analyze/src/options.rs
+++ b/crates/biome_js_analyze/src/options.rs
@@ -38,8 +38,6 @@ pub type NoConfusingLabels =
 pub type NoConfusingVoidType =
     <lint::suspicious::no_confusing_void_type::NoConfusingVoidType as biome_analyze::Rule>::Options;
 pub type NoConsole = <lint::suspicious::no_console::NoConsole as biome_analyze::Rule>::Options;
-pub type NoConsoleLog =
-    <lint::suspicious::no_console_log::NoConsoleLog as biome_analyze::Rule>::Options;
 pub type NoConstAssign =
     <lint::correctness::no_const_assign::NoConstAssign as biome_analyze::Rule>::Options;
 pub type NoConstEnum =
diff --git a/crates/biome_migrate/src/analyzers.rs b/crates/biome_migrate/src/analyzers.rs
index 8ae89f49e893..0d62fe7a6d5c 100644
--- a/crates/biome_migrate/src/analyzers.rs
+++ b/crates/biome_migrate/src/analyzers.rs
@@ -1,4 +1,5 @@
 use crate::analyzers::all::RulesAll;
+use crate::analyzers::deleted_rules::DeletedRules;
 use crate::analyzers::no_var::NoVar;
 use crate::analyzers::nursery_rules::NurseryRules;
 use crate::analyzers::schema::Schema;
@@ -7,6 +8,7 @@ use biome_analyze::{GroupCategory, RegistryVisitor, RuleCategory, RuleGroup};
 use biome_json_syntax::JsonLanguage;
 
 mod all;
+mod deleted_rules;
 mod no_var;
 mod nursery_rules;
 mod schema;
@@ -30,6 +32,7 @@ impl RuleGroup for MigrationGroup {
         registry.record_rule::<RulesAll>();
         registry.record_rule::<StyleRules>();
         registry.record_rule::<NoVar>();
+        registry.record_rule::<DeletedRules>();
     }
 }
 
diff --git a/crates/biome_migrate/src/analyzers/deleted_rules.rs b/crates/biome_migrate/src/analyzers/deleted_rules.rs
new file mode 100644
index 000000000000..26dc5af698e2
--- /dev/null
+++ b/crates/biome_migrate/src/analyzers/deleted_rules.rs
@@ -0,0 +1,324 @@
+use crate::rule_mover::RuleMover;
+use crate::version_services::Version;
+use crate::{declare_migration, MigrationAction};
+use biome_analyze::context::RuleContext;
+use biome_analyze::{Rule, RuleAction, RuleDiagnostic};
+use biome_console::markup;
+use biome_diagnostics::{category, Applicability};
+use biome_json_factory::make::{
+    json_array_element_list, json_array_value, json_member, json_member_list, json_member_name,
+    json_object_value, json_string_literal, json_string_value, token,
+};
+use biome_json_syntax::{AnyJsonValue, JsonMember, JsonRoot, JsonStringValue, T};
+use biome_rowan::{AstNode, TriviaPieceKind, WalkEvent};
+use std::collections::HashMap;
+use std::sync::LazyLock;
+
+declare_migration! {
+    pub(crate) DeletedRules {
+        version: "2.0.0",
+        name: "deletedRules",
+    }
+}
+
+static REMOVED_RULES: LazyLock<HashMap<&'static str, &'static str>> = LazyLock::new(|| {
+    HashMap::from([
+        ("noConsoleLog", "noConsole"),
+        ("useSingleCaseStatement", "noSwitchDeclarations"),
+        ("useShorthandArrayType", "useConsistentArrayType"),
+        ("noNewSymbol", "noInvalidBuiltinInstantiation"),
+    ])
+});
+
+pub(crate) struct RuleState {
+    rule_member: JsonMember,
+    rule_name: Box<str>,
+}
+
+impl Rule for DeletedRules {
+    type Query = Version<JsonRoot>;
+    type State = RuleState;
+    type Signals = Vec<Self::State>;
+    type Options = ();
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let node = ctx.query();
+        let version = ctx.version();
+
+        if version != "2.0.0" {
+            return vec![];
+        }
+        let mut rules = vec![];
+        let events = node.syntax().preorder();
+
+        for event in events {
+            match event {
+                WalkEvent::Enter(node) => {
+                    let member = JsonMember::cast(node);
+                    if let Some(member) = member {
+                        let Ok(name) = member.name() else { continue };
+
+                        let Ok(node_text) = name.inner_string_text() else {
+                            continue;
+                        };
+
+                        if REMOVED_RULES.contains_key(node_text.text()) {
+                            rules.push(RuleState {
+                                rule_member: member,
+                                rule_name: Box::from(node_text.text()),
+                            });
+                        }
+                    }
+                }
+                WalkEvent::Leave(_) => {}
+            }
+        }
+
+        rules
+    }
+
+    fn diagnostic(_ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
+        let name = state.rule_member.name().ok()?;
+        Some(RuleDiagnostic::new(
+            category!("migrate"),
+            name.range(),
+            markup! {
+                "The rule "<Emphasis>"noConsoleLog"</Emphasis>" has been removed."
+            }
+            .to_owned(),
+        ))
+    }
+
+    fn action(ctx: &RuleContext<Self>, state: &Self::State) -> Option<MigrationAction> {
+        let mut rule_mover = RuleMover::from_root(ctx.root());
+        let member = &state.rule_member;
+
+        let value = member.value().ok()?;
+        let value = match value {
+            AnyJsonValue::JsonStringValue(json_string_value) => Some(json_string_value),
+            AnyJsonValue::JsonObjectValue(json_object_value) => {
+                let list = json_object_value.json_member_list();
+                let mut value = None;
+                for item in list.into_iter().flatten() {
+                    let text = item.name().ok().and_then(|n| n.inner_string_text().ok());
+                    if let Some(text) = text {
+                        if text.text() == "level" {
+                            value = item.value().ok()?.as_json_string_value().cloned();
+                        }
+                    }
+                }
+
+                value
+            }
+            _ => None,
+        };
+
+        if REMOVED_RULES.contains_key(state.rule_name.as_ref()) {
+            let (member, group) = match state.rule_name.as_ref() {
+                "noConsoleLog" => (create_console_log_member(value), "suspicious"),
+                "useSingleCaseStatement" => (create_no_switch_declarations(value), "correctness"),
+                "useShorthandArrayType" => (create_consistent_array_type(value), "style"),
+                "noNewSymbol" | "noInvalidNewBuiltin" => {
+                    (create_no_invalid_builtin(value), "correctness")
+                }
+                _ => return None,
+            };
+            rule_mover.replace_rule(state.rule_name.as_ref(), member, group);
+        }
+
+        let mutation = rule_mover.run_queries()?;
+
+        Some(RuleAction::new(
+            ctx.metadata().action_category(ctx.category(), ctx.group()),
+            Applicability::Always,
+            markup! {
+                "Use the rule "<Emphasis>"useConsole"</Emphasis>" instead."
+            }
+            .to_owned(),
+            mutation,
+        ))
+    }
+}
+
+/// Creates the member for `noConsoleLog`
+fn create_console_log_member(value: Option<JsonStringValue>) -> JsonMember {
+    let allow_option = json_member(
+        json_member_name(json_string_literal("allow").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(12).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonArrayValue(json_array_value(
+            token(T!['[']),
+            json_array_element_list(
+                vec![AnyJsonValue::JsonStringValue(json_string_value(
+                    json_string_literal("log"),
+                ))],
+                vec![],
+            ),
+            token(T![']']),
+        )),
+    );
+    let rule_options = json_member(
+        json_member_name(json_string_literal("options").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonObjectValue(json_object_value(
+            token(T!['{']),
+            json_member_list(vec![allow_option], vec![]),
+            token(T!['}']).with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+            ]),
+        )),
+    );
+
+    let level_option = json_member(
+        json_member_name(json_string_literal("level").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonStringValue(
+            value.unwrap_or(json_string_value(json_string_literal("error"))),
+        ),
+    );
+
+    json_member(
+        json_member_name(json_string_literal("noConsole").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonObjectValue(json_object_value(
+            token(T!['{']),
+            json_member_list(vec![level_option, rule_options], vec![token(T![,])]),
+            token(T!['}']).with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+            ]),
+        )),
+    )
+}
+
+/// Creates the member for `noSwitchDeclarations`
+fn create_no_switch_declarations(value: Option<JsonStringValue>) -> JsonMember {
+    let level_option = json_member(
+        json_member_name(json_string_literal("level").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonStringValue(
+            value.unwrap_or(json_string_value(json_string_literal("error"))),
+        ),
+    );
+
+    json_member(
+        json_member_name(
+            json_string_literal("noSwitchDeclarations").with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+            ]),
+        ),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonObjectValue(json_object_value(
+            token(T!['{']),
+            json_member_list(vec![level_option], vec![]),
+            token(T!['}']).with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+            ]),
+        )),
+    )
+}
+
+/// Creates the member for `useConsistentArrayType`
+fn create_consistent_array_type(value: Option<JsonStringValue>) -> JsonMember {
+    let allow_option = json_member(
+        json_member_name(json_string_literal("syntax").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(12).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonStringValue(json_string_value(json_string_literal("shorthand"))),
+    );
+    let rule_options = json_member(
+        json_member_name(json_string_literal("options").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonObjectValue(json_object_value(
+            token(T!['{']),
+            json_member_list(vec![allow_option], vec![]),
+            token(T!['}']).with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+            ]),
+        )),
+    );
+
+    let level_option = json_member(
+        json_member_name(json_string_literal("level").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonStringValue(
+            value.unwrap_or(json_string_value(json_string_literal("warn"))),
+        ),
+    );
+
+    json_member(
+        json_member_name(
+            json_string_literal("useConsistentArrayType").with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+            ]),
+        ),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonObjectValue(json_object_value(
+            token(T!['{']),
+            json_member_list(vec![level_option, rule_options], vec![token(T![,])]),
+            token(T!['}']).with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+            ]),
+        )),
+    )
+}
+
+/// Creates the member for `noInvalidBuiltinInstantiation`
+fn create_no_invalid_builtin(value: Option<JsonStringValue>) -> JsonMember {
+    let level_option = json_member(
+        json_member_name(json_string_literal("level").with_leading_trivia(vec![
+            (TriviaPieceKind::Newline, "\n"),
+            (TriviaPieceKind::Whitespace, " ".repeat(10).as_str()),
+        ])),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonStringValue(
+            value.unwrap_or(json_string_value(json_string_literal("warn"))),
+        ),
+    );
+
+    json_member(
+        json_member_name(
+            json_string_literal("noInvalidBuiltinInstantiation").with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+            ]),
+        ),
+        token(T![:]).with_trailing_trivia(vec![(TriviaPieceKind::Whitespace, " ")]),
+        AnyJsonValue::JsonObjectValue(json_object_value(
+            token(T!['{']),
+            json_member_list(vec![level_option], vec![]),
+            token(T!['}']).with_leading_trivia(vec![
+                (TriviaPieceKind::Newline, "\n"),
+                (TriviaPieceKind::Whitespace, " ".repeat(8).as_str()),
+            ]),
+        )),
+    )
+}
diff --git a/crates/biome_migrate/src/rule_mover.rs b/crates/biome_migrate/src/rule_mover.rs
index 2cf212a8fd8a..3d101647f4c6 100644
--- a/crates/biome_migrate/src/rule_mover.rs
+++ b/crates/biome_migrate/src/rule_mover.rs
@@ -421,36 +421,28 @@ fn group_member(
     group_name: &str,
 ) -> JsonMember {
     let list = json_member_list(members, separators);
-    let object = create_object(list, 8);
+    let object = create_object(list, 6);
     create_member(group_name, AnyJsonValue::JsonObjectValue(object), 6)
 }
 
-fn rules_member(
-    members: Vec<JsonMember>,
-    separators: Vec<JsonSyntaxToken>,
-    indentation: usize,
-) -> JsonMember {
+fn rules_member(members: Vec<JsonMember>, separators: Vec<JsonSyntaxToken>) -> JsonMember {
     let list = json_member_list(members, separators);
-    let object = create_object(list, indentation);
+    let object = create_object(list, 4);
     create_member("rules", AnyJsonValue::JsonObjectValue(object), 4)
 }
 
-fn linter_member(
-    members: Vec<JsonMember>,
-    separators: Vec<JsonSyntaxToken>,
-    indentation: usize,
-) -> JsonMember {
+fn linter_member(members: Vec<JsonMember>, separators: Vec<JsonSyntaxToken>) -> JsonMember {
     let list = json_member_list(members, separators);
-    let object = create_object(list, indentation);
-    create_member("linter", AnyJsonValue::JsonObjectValue(object), indentation)
+    let object = create_object(list, 2);
+    create_member("linter", AnyJsonValue::JsonObjectValue(object), 2)
 }
 
 fn create_new_linter_member(
     members: Vec<JsonMember>,
     separators: Vec<JsonSyntaxToken>,
 ) -> JsonMember {
-    let rules = rules_member(members, separators, 4);
-    linter_member(vec![rules], vec![], 2)
+    let rules = rules_member(members, separators);
+    linter_member(vec![rules], vec![])
 }
 
 #[cfg(test)]
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index 0d077ce4026b..e211332253dd 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -1743,10 +1743,6 @@ export interface Suspicious {
 	 * Disallow the use of console.
 	 */
 	noConsole?: RuleFixConfiguration_for_NoConsoleOptions;
-	/**
-	 * Disallow the use of console.log
-	 */
-	noConsoleLog?: RuleFixConfiguration_for_Null;
 	/**
 	 * Disallow TypeScript const enum
 	 */
@@ -3224,7 +3220,6 @@ export type Category =
 	| "lint/suspicious/noConfusingLabels"
 	| "lint/suspicious/noConfusingVoidType"
 	| "lint/suspicious/noConsole"
-	| "lint/suspicious/noConsoleLog"
 	| "lint/suspicious/noConstEnum"
 	| "lint/suspicious/noControlCharactersInRegex"
 	| "lint/suspicious/noDebugger"
diff --git a/packages/@biomejs/biome/configuration_schema.json b/packages/@biomejs/biome/configuration_schema.json
index b3e891612ec8..4a658faaafd4 100644
--- a/packages/@biomejs/biome/configuration_schema.json
+++ b/packages/@biomejs/biome/configuration_schema.json
@@ -3979,13 +3979,6 @@
 						{ "type": "null" }
 					]
 				},
-				"noConsoleLog": {
-					"description": "Disallow the use of console.log",
-					"anyOf": [
-						{ "$ref": "#/definitions/RuleFixConfiguration" },
-						{ "type": "null" }
-					]
-				},
 				"noConstEnum": {
 					"description": "Disallow TypeScript const enum",
 					"anyOf": [


Test patch:
diff --git a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/invalid.js b/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/invalid.js
deleted file mode 100644
index a7bcba21ad85..000000000000
--- a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/invalid.js
+++ /dev/null
@@ -1,2 +0,0 @@
-console.log("something")
-console.log("with semicolon");
diff --git a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/invalid.js.snap b/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/invalid.js.snap
deleted file mode 100644
index 0ff53af3dce8..000000000000
--- a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/invalid.js.snap
+++ /dev/null
@@ -1,56 +0,0 @@
----
-source: crates/biome_js_analyze/tests/spec_tests.rs
-expression: invalid.js
-snapshot_kind: text
----
-# Input
-```js
-console.log("something")
-console.log("with semicolon");
-
-```
-
-# Diagnostics
-```
-invalid.js:1:1 lint/suspicious/noConsoleLog  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  ! Don't use console.log
-  
-  > 1 │ console.log("something")
-      │ ^^^^^^^^^^^^^^^^^^^^^^^^
-    2 │ console.log("with semicolon");
-    3 │ 
-  
-  i console.log is usually a tool for debugging and you don't want to have that in production.
-  
-  i If it is not for debugging purpose then using console.info might be more appropriate.
-  
-  i Unsafe fix: Remove console.log
-  
-    1 │ console.log("something")
-      │ ------------------------
-
-```
-
-```
-invalid.js:2:1 lint/suspicious/noConsoleLog  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-  ! Don't use console.log
-  
-    1 │ console.log("something")
-  > 2 │ console.log("with semicolon");
-      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-    3 │ 
-  
-  i console.log is usually a tool for debugging and you don't want to have that in production.
-  
-  i If it is not for debugging purpose then using console.info might be more appropriate.
-  
-  i Unsafe fix: Remove console.log
-  
-    1 1 │   console.log("something")
-    2   │ - console.log("with·semicolon");
-    3 2 │   
-  
-
-```
diff --git a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/valid.js b/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/valid.js
deleted file mode 100644
index 2397c4d95124..000000000000
--- a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/valid.js
+++ /dev/null
@@ -1,8 +0,0 @@
-const console = {
-	log() {}
-};
-console.log();
-console.info("info");
-console.warn("warn");
-console.error("error");
-console.assert(true);
diff --git a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/valid.js.snap b/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/valid.js.snap
deleted file mode 100644
index bf72f92d075d..000000000000
--- a/crates/biome_js_analyze/tests/specs/suspicious/noConsoleLog/valid.js.snap
+++ /dev/null
@@ -1,17 +0,0 @@
----
-source: crates/biome_js_analyze/tests/spec_tests.rs
-expression: valid.js
-snapshot_kind: text
----
-# Input
-```js
-const console = {
-	log() {}
-};
-console.log();
-console.info("info");
-console.warn("warn");
-console.error("error");
-console.assert(true);
-
-```
diff --git a/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.json b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.json
new file mode 100644
index 000000000000..fc31e0e651d4
--- /dev/null
+++ b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.json
@@ -0,0 +1,13 @@
+{
+  "linter": {
+    "rules": {
+      "suspicious": {
+        "noConsoleLog": "error",
+        "useSingleCaseStatement": "error",
+        "useShorthandArrayType": "error",
+        "noNewSymbol": "error",
+        "noInvalidNewBuiltin": "error"
+      }
+    }
+  }
+}
diff --git a/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.json.snap b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.json.snap
new file mode 100644
index 000000000000..d79abe7eda37
--- /dev/null
+++ b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.json.snap
@@ -0,0 +1,150 @@
+---
+source: crates/biome_migrate/tests/spec_tests.rs
+expression: invalid.json
+snapshot_kind: text
+---
+# Input
+```json
+{
+  "linter": {
+    "rules": {
+      "suspicious": {
+        "noConsoleLog": "error",
+        "useSingleCaseStatement": "error",
+        "useShorthandArrayType": "error",
+        "noNewSymbol": "error",
+        "noInvalidNewBuiltin": "error"
+      }
+    }
+  }
+}
+
+```
+
+# Diagnostics
+```
+invalid.json:5:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+    3 │     "rules": {
+    4 │       "suspicious": {
+  > 5 │         "noConsoleLog": "error",
+      │         ^^^^^^^^^^^^^^
+    6 │         "useSingleCaseStatement": "error",
+    7 │         "useShorthandArrayType": "error",
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+     3  3 │       "rules": {
+     4  4 │         "suspicious": {
+     5    │ - ········"noConsoleLog":·"error",
+     6    │ - ········"useSingleCaseStatement":·"error",
+     7    │ - ········"useShorthandArrayType":·"error",
+     8    │ - ········"noNewSymbol":·"error",
+     9    │ - ········"noInvalidNewBuiltin":·"error"
+        5 │ + ········"useSingleCaseStatement":·"error",
+        6 │ + ········"useShorthandArrayType":·"error",
+        7 │ + ········"noNewSymbol":·"error",
+        8 │ + ········"noInvalidNewBuiltin":·"error",
+        9 │ + ········"noConsole":·{
+       10 │ + ··········"level":·"error",
+       11 │ + ··········"options":·{
+       12 │ + ············"allow":·["log"]
+       13 │ + ··········}
+       14 │ + ········}
+    10 15 │         }
+    11 16 │       }
+  
+
+```
+
+```
+invalid.json:6:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+    4 │       "suspicious": {
+    5 │         "noConsoleLog": "error",
+  > 6 │         "useSingleCaseStatement": "error",
+      │         ^^^^^^^^^^^^^^^^^^^^^^^^
+    7 │         "useShorthandArrayType": "error",
+    8 │         "noNewSymbol": "error",
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+     8  8 │           "noNewSymbol": "error",
+     9  9 │           "noInvalidNewBuiltin": "error"
+    10    │ - ······}
+       10 │ + ······},
+       11 │ + ······"correctness":·{
+       12 │ + ········"noSwitchDeclarations":·{
+       13 │ + ··········"level":·"error"
+       14 │ + ········}
+       15 │ + ······}
+    11 16 │       }
+    12 17 │     }
+  
+
+```
+
+```
+invalid.json:7:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+    5 │         "noConsoleLog": "error",
+    6 │         "useSingleCaseStatement": "error",
+  > 7 │         "useShorthandArrayType": "error",
+      │         ^^^^^^^^^^^^^^^^^^^^^^^
+    8 │         "noNewSymbol": "error",
+    9 │         "noInvalidNewBuiltin": "error"
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+     2  2 │     "linter": {
+     3  3 │       "rules": {
+     4    │ - ······"suspicious":·{
+        4 │ + ······"style":·{
+        5 │ + ········"useConsistentArrayType":·{
+        6 │ + ··········"level":·"error",
+        7 │ + ··········"options":·{
+        8 │ + ············"syntax":·"shorthand"
+        9 │ + ··········}
+       10 │ + ········}
+       11 │ + ······},
+       12 │ + ······"suspicious":·{
+     5 13 │           "noConsoleLog": "error",
+     6 14 │           "useSingleCaseStatement": "error",
+  
+
+```
+
+```
+invalid.json:8:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+     6 │         "useSingleCaseStatement": "error",
+     7 │         "useShorthandArrayType": "error",
+   > 8 │         "noNewSymbol": "error",
+       │         ^^^^^^^^^^^^^
+     9 │         "noInvalidNewBuiltin": "error"
+    10 │       }
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+     8  8 │           "noNewSymbol": "error",
+     9  9 │           "noInvalidNewBuiltin": "error"
+    10    │ - ······}
+       10 │ + ······},
+       11 │ + ······"correctness":·{
+       12 │ + ········"noInvalidBuiltinInstantiation":·{
+       13 │ + ··········"level":·"error"
+       14 │ + ········}
+       15 │ + ······}
+    11 16 │       }
+    12 17 │     }
+  
+
+```
diff --git a/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.version.txt b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.version.txt
new file mode 100644
index 000000000000..227cea215648
--- /dev/null
+++ b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid.version.txt
@@ -0,0 +1,1 @@
+2.0.0
diff --git a/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.json b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.json
new file mode 100644
index 000000000000..6a50ae49b8a9
--- /dev/null
+++ b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.json
@@ -0,0 +1,23 @@
+{
+  "linter": {
+    "rules": {
+      "suspicious": {
+        "noConsoleLog": {
+          "level": "warn"
+        },
+        "useSingleCaseStatement": {
+          "level": "error"
+        },
+        "useShorthandArrayType": {
+          "level": "error"
+        },
+        "noNewSymbol": {
+          "level": "error"
+        },
+        "noInvalidNewBuiltin": {
+          "level": "error"
+        }
+      }
+    }
+  }
+}
diff --git a/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.json.snap b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.json.snap
new file mode 100644
index 000000000000..c3ff01af2e20
--- /dev/null
+++ b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.json.snap
@@ -0,0 +1,169 @@
+---
+source: crates/biome_migrate/tests/spec_tests.rs
+expression: invalid_with_level.json
+snapshot_kind: text
+---
+# Input
+```json
+{
+  "linter": {
+    "rules": {
+      "suspicious": {
+        "noConsoleLog": {
+          "level": "warn"
+        },
+        "useSingleCaseStatement": {
+          "level": "error"
+        },
+        "useShorthandArrayType": {
+          "level": "error"
+        },
+        "noNewSymbol": {
+          "level": "error"
+        },
+        "noInvalidNewBuiltin": {
+          "level": "error"
+        }
+      }
+    }
+  }
+}
+
+```
+
+# Diagnostics
+```
+invalid_with_level.json:5:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+    3 │     "rules": {
+    4 │       "suspicious": {
+  > 5 │         "noConsoleLog": {
+      │         ^^^^^^^^^^^^^^
+    6 │           "level": "warn"
+    7 │         },
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+     3  3 │       "rules": {
+     4  4 │         "suspicious": {
+     5    │ - ········"noConsoleLog":·{
+     6    │ - ··········"level":·"warn"
+        5 │ + ········"useSingleCaseStatement":·{
+        6 │ + ··········"level":·"error"
+     7  7 │           },
+     8    │ - ········"useSingleCaseStatement":·{
+        8 │ + ········"useShorthandArrayType":·{
+     9  9 │             "level": "error"
+    10 10 │           },
+    11    │ - ········"useShorthandArrayType":·{
+       11 │ + ········"noNewSymbol":·{
+    12 12 │             "level": "error"
+    13 13 │           },
+    14    │ - ········"noNewSymbol":·{
+       14 │ + ········"noInvalidNewBuiltin":·{
+    15 15 │             "level": "error"
+    16 16 │           },
+    17    │ - ········"noInvalidNewBuiltin":·{
+    18    │ - ··········"level":·"error"
+       17 │ + ········"noConsole":·{
+       18 │ + ··········"level":·"warn",
+       19 │ + ··········"options":·{
+       20 │ + ············"allow":·["log"]
+       21 │ + ··········}
+    19 22 │           }
+    20 23 │         }
+  
+
+```
+
+```
+invalid_with_level.json:8:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+     6 │           "level": "warn"
+     7 │         },
+   > 8 │         "useSingleCaseStatement": {
+       │         ^^^^^^^^^^^^^^^^^^^^^^^^
+     9 │           "level": "error"
+    10 │         },
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+    18 18 │             "level": "error"
+    19 19 │           }
+    20    │ - ······}
+       20 │ + ······},
+       21 │ + ······"correctness":·{
+       22 │ + ········"noSwitchDeclarations":·{
+       23 │ + ··········"level":·"error"
+       24 │ + ········}
+       25 │ + ······}
+    21 26 │       }
+    22 27 │     }
+  
+
+```
+
+```
+invalid_with_level.json:11:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+     9 │           "level": "error"
+    10 │         },
+  > 11 │         "useShorthandArrayType": {
+       │         ^^^^^^^^^^^^^^^^^^^^^^^
+    12 │           "level": "error"
+    13 │         },
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+     2  2 │     "linter": {
+     3  3 │       "rules": {
+     4    │ - ······"suspicious":·{
+        4 │ + ······"style":·{
+        5 │ + ········"useConsistentArrayType":·{
+        6 │ + ··········"level":·"error",
+        7 │ + ··········"options":·{
+        8 │ + ············"syntax":·"shorthand"
+        9 │ + ··········}
+       10 │ + ········}
+       11 │ + ······},
+       12 │ + ······"suspicious":·{
+     5 13 │           "noConsoleLog": {
+     6 14 │             "level": "warn"
+  
+
+```
+
+```
+invalid_with_level.json:14:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The rule noConsoleLog has been removed.
+  
+    12 │           "level": "error"
+    13 │         },
+  > 14 │         "noNewSymbol": {
+       │         ^^^^^^^^^^^^^
+    15 │           "level": "error"
+    16 │         },
+  
+  i Safe fix: Use the rule useConsole instead.
+  
+    18 18 │             "level": "error"
+    19 19 │           }
+    20    │ - ······}
+       20 │ + ······},
+       21 │ + ······"correctness":·{
+       22 │ + ········"noInvalidBuiltinInstantiation":·{
+       23 │ + ··········"level":·"error"
+       24 │ + ········}
+       25 │ + ······}
+    21 26 │       }
+    22 27 │     }
+  
+
+```
diff --git a/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.version.txt b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.version.txt
new file mode 100644
index 000000000000..227cea215648
--- /dev/null
+++ b/crates/biome_migrate/tests/specs/migrations/deletedRules/invalid_with_level.version.txt
@@ -0,0 +1,1 @@
+2.0.0
diff --git a/crates/biome_migrate/tests/specs/migrations/noVar/invalid.json.snap b/crates/biome_migrate/tests/specs/migrations/noVar/invalid.json.snap
index f35951d82eb4..67635f3a486f 100644
--- a/crates/biome_migrate/tests/specs/migrations/noVar/invalid.json.snap
+++ b/crates/biome_migrate/tests/specs/migrations/noVar/invalid.json.snap
@@ -37,10 +37,7 @@ invalid.json:5:9 migrate  FIXABLE  ━━━━━━━━━━━━━━━
      4    │ - ······"style":·{
         4 │ + ······"suspicious":·{
      5  5 │           "noVar": "error"
-     6    │ - ······}
-        6 │ + ········}
-     7  7 │       }
-     8  8 │     }
+     6  6 │         }
   
 
 ```
diff --git a/crates/biome_migrate/tests/specs/migrations/styleRules/empty.json.snap b/crates/biome_migrate/tests/specs/migrations/styleRules/empty.json.snap
index 9227128ea978..b9ff1fed4662 100644
--- a/crates/biome_migrate/tests/specs/migrations/styleRules/empty.json.snap
+++ b/crates/biome_migrate/tests/specs/migrations/styleRules/empty.json.snap
@@ -58,7 +58,7 @@ empty.json:1:1 migrate  FIXABLE  ━━━━━━━━━━━━━━━
       27 │ + ········"useNumericLiterals":"error",
       28 │ + ········"useTemplate":"error",
       29 │ + ········"useEnumInitializers":"error"
-      30 │ + ········}
+      30 │ + ······}
       31 │ + ····}
       32 │ + ··}
     4 33 │   }
diff --git a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_linter.json.snap b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_linter.json.snap
index 307c13453228..57126237a598 100644
--- a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_linter.json.snap
+++ b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_linter.json.snap
@@ -54,7 +54,7 @@ with_existing_linter.json:1:1 migrate  FIXABLE  ━━━━━━━━━━
       25 │ + ········"useNumericLiterals":"error",
       26 │ + ········"useTemplate":"error",
       27 │ + ········"useEnumInitializers":"error"
-      28 │ + ········}
+      28 │ + ······}
       29 │ + ····}
       30 │ + ··}
     3 31 │   }
diff --git a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_rules.json.snap b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_rules.json.snap
index 4d76bb996924..297378586a02 100644
--- a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_rules.json.snap
+++ b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_rules.json.snap
@@ -61,7 +61,7 @@ with_existing_rules.json:1:1 migrate  FIXABLE  ━━━━━━━━━━━
       25 │ + ········"useNumericLiterals":"error",
       26 │ + ········"useTemplate":"error",
       27 │ + ········"useEnumInitializers":"error"
-      28 │ + ········}
+      28 │ + ······}
     5 29 │       }
     6 30 │     }
   
diff --git a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_style_rule.json.snap b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_style_rule.json.snap
index 1d6b5261947c..d758486f55ce 100644
--- a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_style_rule.json.snap
+++ b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_style_rule.json.snap
@@ -56,7 +56,6 @@ with_existing_style_rule.json:1:1 migrate  FIXABLE  ━━━━━━━━━
      9  8 │           "useShorthandFunctionType": "warn",
     10  9 │           "useExportType":  "warn",
     11    │ - ········"useDefaultParameterLast":·"warn"
-    12    │ - ······}
        10 │ + ········"useDefaultParameterLast":·"warn",
        11 │ + ········"noCommaOperator":"error",
        12 │ + ········"useSingleVarDeclarator":"error",
@@ -75,9 +74,8 @@ with_existing_style_rule.json:1:1 migrate  FIXABLE  ━━━━━━━━━
        25 │ + ········"useNumericLiterals":"error",
        26 │ + ········"useTemplate":"error",
        27 │ + ········"useEnumInitializers":"error"
-       28 │ + ········}
+    12 28 │         }
     13 29 │       }
-    14 30 │     }
   
 
 ```
diff --git a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_styles.json.snap b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_styles.json.snap
index 2f1fb71817d1..29835e595ff0 100644
--- a/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_styles.json.snap
+++ b/crates/biome_migrate/tests/specs/migrations/styleRules/with_existing_styles.json.snap
@@ -64,7 +64,7 @@ with_existing_styles.json:1:1 migrate  FIXABLE  ━━━━━━━━━━
       25 │ + ········"useNumericLiterals":"error",
       26 │ + ········"useTemplate":"error",
       27 │ + ········"useEnumInitializers":"error"
-      28 │ + ········}
+      28 │ + ······}
     6 29 │       }
     7 30 │     }