feat: add useDefaultSwitchClause rule

crates/biome_diagnostics_categories/src/categories.rs

@@ -135,6 +135,7 @@ define_categories! {
     "lint/nursery/useBiomeSuppressionComment": "https://biomejs.dev/linter/rules/use-biome-suppression-comment",
     "lint/nursery/useConsistentNewBuiltin": "https://biomejs.dev/linter/rules/use-consistent-new-builtin",
     "lint/nursery/useGenericFontNames": "https://biomejs.dev/linter/rules/use-generic-font-names",
+    "lint/nursery/useDefaultSwitchClause": "https://biomejs.dev/linter/rules/use-default-switch-clause",
     "lint/nursery/useImportRestrictions": "https://biomejs.dev/linter/rules/use-import-restrictions",
     "lint/nursery/useSortedClasses": "https://biomejs.dev/linter/rules/use-sorted-classes",
     "lint/performance/noAccumulatingSpread": "https://biomejs.dev/linter/rules/no-accumulating-spread",

crates/biome_js_analyze/src/lint/nursery/use_default_switch_clause.rs

@@ -0,0 +1,93 @@
+use std::ops::Not;
+
+use biome_analyze::{context::RuleContext, declare_rule, Ast, Rule, RuleDiagnostic, RuleSource};
+use biome_console::markup;
+use biome_js_syntax::JsSwitchStatement;
+use biome_rowan::AstNode;
+
+declare_rule! {
+    /// Require default cases in switch statements.
+    ///
+    /// Some code conventions require that all switch statements have a default case. The thinking is that it’s better
+    /// to always explicitly state what the default behavior should be so that it’s clear whether or not the developer
+    /// forgot to include the default behavior by mistake.
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```js,expect_diagnostic
+    /// switch (a) {
+    ///     case 1:
+    ///         /* code */
+    ///         break;
+    /// }
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```js
+    /// switch (a) {
+    ///     case 1:
+    ///         /* code */
+    ///         break;
+    ///
+    ///     default:
+    ///         /* code */
+    ///         break;
+    /// }
+    /// ```
+    ///
+    /// ```js
+    /// switch (a) {
+    /// }
+    /// ```
+    pub UseDefaultSwitchClause {
+        version: "next",
+        name: "useDefaultSwitchClause",
+        sources: &[RuleSource::Eslint("default-case")],
+        recommended: false,
+    }
+}
+
+impl Rule for UseDefaultSwitchClause {
+    type Query = Ast<JsSwitchStatement>;
+    type State = ();
+    type Signals = Option<Self::State>;
+    type Options = ();
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let node = ctx.query();
+
+        let has_case_clauses = node.cases().into_iter().len() > 0;
+        let is_missing_default_case = node
+            .cases()
+            .into_iter()
+            .any(|clause| clause.as_js_default_clause().is_some())
+            .not();
+
+        let is_valid = is_missing_default_case && has_case_clauses;
+
+        is_valid.then_some(())
+    }
+
+    fn diagnostic(ctx: &RuleContext<Self>, _state: &Self::State) -> Option<RuleDiagnostic> {
+        let node = ctx.query();
+
+        Some(
+            RuleDiagnostic::new(
+                rule_category!(),
+                node.range(),
+                markup! {
+                    "Expected a default case."
+                },
+            )
+            .note(markup! {
+                "The lack of a default clause can be a possible omission."
+            })
+            .note(markup! {
+                "Consider adding a default clause."
+            }),
+        )
+    }
+}

crates/biome_js_analyze/src/options.rs

@@ -263,6 +263,7 @@ pub type UseConsistentArrayType = < lint :: style :: use_consistent_array_type :
 pub type UseConsistentNewBuiltin = < lint :: nursery :: use_consistent_new_builtin :: UseConsistentNewBuiltin as biome_analyze :: Rule > :: Options ;
 pub type UseConst = <lint::style::use_const::UseConst as biome_analyze::Rule>::Options;
 pub type UseDefaultParameterLast = < lint :: style :: use_default_parameter_last :: UseDefaultParameterLast as biome_analyze :: Rule > :: Options ;
+pub type UseDefaultSwitchClause = < lint :: nursery :: use_default_switch_clause :: UseDefaultSwitchClause as biome_analyze :: Rule > :: Options ;
 pub type UseDefaultSwitchClauseLast = < lint :: suspicious :: use_default_switch_clause_last :: UseDefaultSwitchClauseLast as biome_analyze :: Rule > :: Options ;
 pub type UseEnumInitializers =
     <lint::style::use_enum_initializers::UseEnumInitializers as biome_analyze::Rule>::Options;

crates/biome_js_analyze/tests/specs/nursery/useDefaultSwitchClause/invalid.js

@@ -0,0 +1,4 @@
+switch (a) {
+	case 1:
+		break;
+}

crates/biome_js_analyze/tests/specs/nursery/useDefaultSwitchClause/invalid.js.snap

@@ -0,0 +1,33 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: invalid.js
+---
+# Input
+```jsx
+switch (a) {
+	case 1:
+		break;
+}
+
+```
+
+# Diagnostics
+```
+invalid.js:1:1 lint/nursery/useDefaultSwitchClause ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Expected a default case.
+
+  > 1 │ switch (a) {
+      │ ^^^^^^^^^^^^
+  > 2 │ 	case 1:
+  > 3 │ 		break;
+  > 4 │ }
+      │ ^
+    5 │ 
+
+  i The lack of a default clause can be a possible omission.
+
+  i Consider adding a default clause.
+
+
+```

crates/biome_js_analyze/tests/specs/nursery/useDefaultSwitchClause/valid.js

@@ -0,0 +1,17 @@
+switch (a) {
+	case 1:
+		break;
+	default:
+		break;
+}
+
+switch (a) {
+	case 1:
+		break;
+	case 2:
+	default:
+		break;
+}
+
+switch (a) {
+}

crates/biome_js_analyze/tests/specs/nursery/useDefaultSwitchClause/valid.js.snap

@@ -0,0 +1,25 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: valid.js
+---
+# Input
+```jsx
+switch (a) {
+	case 1:
+		break;
+	default:
+		break;
+}
+
+switch (a) {
+	case 1:
+		break;
+	case 2:
+	default:
+		break;
+}
+
+switch (a) {
+}
+
+```