feat(linter/strict-boolean-expression): add rule

Author: camc314

apps/oxlint/fixtures/tsgolint/.oxlintrc.json

@@ -39,6 +39,7 @@
     "typescript/restrict-plus-operands": "error",
     "typescript/restrict-template-expressions": "error",
     "typescript/return-await": "error",
+    "typescript/strict-boolean-expressions": "error",
     "typescript/switch-exhaustiveness-check": "error",
     "typescript/unbound-method": "error",
     "typescript/use-unknown-in-catch-callback-variable": "error",

apps/oxlint/fixtures/tsgolint/strict-boolean-expressions/index.ts

@@ -0,0 +1,67 @@
+// Examples of incorrect code for strict-boolean-expressions rule
+
+// Non-boolean values in conditions
+const str = 'hello';
+if (str) { // string is not a boolean
+  console.log('string');
+}
+
+const num = 42;
+if (num) { // number is not a boolean
+  console.log('number');
+}
+
+const obj = { foo: 'bar' };
+if (obj) { // object is not a boolean
+  console.log('object');
+}
+
+// Nullable booleans
+declare const maybeBool: boolean | null;
+if (maybeBool) { // nullable boolean
+  console.log('maybe');
+}
+
+// Undefined checks
+declare const maybeString: string | undefined;
+if (maybeString) { // should explicitly check !== undefined
+  console.log(maybeString);
+}
+
+// Logical operators with non-booleans
+const result1 = str && num;
+const result2 = obj || num;
+
+// While loops with non-boolean
+while (num) {
+  console.log('loop');
+  break;
+}
+
+// Do-while with non-boolean
+do {
+  console.log('do');
+} while (str);
+
+// For loop with non-boolean
+for (let i = 0; i; i++) {
+  console.log('for');
+}
+
+// Ternary with non-boolean
+const ternary = str ? 'yes' : 'no';
+
+// Logical NOT on non-boolean
+const negated = !str;
+
+// Mixed types in logical expressions
+declare const mixed: string | number;
+if (mixed) {
+  console.log('mixed');
+}
+
+// any type (should allow or warn depending on config)
+declare const anyValue: any;
+if (anyValue) {
+  console.log('any');
+}

crates/oxc_linter/src/generated/rule_runner_impls.rs

@@ -2943,6 +2943,11 @@ impl RuleRunner for crate::rules::typescript::return_await::ReturnAwait {
     const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Unknown;
 }
 
+impl RuleRunner for crate::rules::typescript::strict_boolean_expressions::StrictBooleanExpressions {
+    const NODE_TYPES: Option<&AstTypesBitset> = None;
+    const RUN_FUNCTIONS: RuleRunFunctionsImplemented = RuleRunFunctionsImplemented::Unknown;
+}
+
 impl RuleRunner
     for crate::rules::typescript::switch_exhaustiveness_check::SwitchExhaustivenessCheck
 {

crates/oxc_linter/src/rules.rs

@@ -278,6 +278,7 @@ pub(crate) mod typescript {
     pub mod restrict_plus_operands;
     pub mod restrict_template_expressions;
     pub mod return_await;
+    pub mod strict_boolean_expressions;
     pub mod switch_exhaustiveness_check;
     pub mod triple_slash_reference;
     pub mod unbound_method;
@@ -1136,6 +1137,7 @@ oxc_macros::declare_all_lint_rules! {
     typescript::restrict_plus_operands,
     typescript::restrict_template_expressions,
     typescript::return_await,
+    typescript::strict_boolean_expressions,
     typescript::switch_exhaustiveness_check,
     typescript::triple_slash_reference,
     typescript::unbound_method,

crates/oxc_linter/src/rules/typescript/strict_boolean_expressions.rs

@@ -0,0 +1,86 @@
+use oxc_macros::declare_oxc_lint;
+
+use crate::rule::Rule;
+
+#[derive(Debug, Default, Clone)]
+pub struct StrictBooleanExpressions;
+
+declare_oxc_lint!(
+    /// ### What it does
+    ///
+    /// Disallow certain types in boolean expressions.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// Forbids usage of non-boolean types in expressions where a boolean is expected.
+    /// `boolean` and `never` types are always allowed. Additional types which are
+    /// considered safe in a boolean context can be configured via options.
+    ///
+    /// The following nodes are checked:
+    ///
+    /// - Arguments to the `!`, `&&`, and `||` operators
+    /// - The condition in a conditional expression (`cond ? x : y`)
+    /// - Conditions for `if`, `for`, `while`, and `do-while` statements.
+    ///
+    /// ### Examples
+    ///
+    /// Examples of **incorrect** code for this rule:
+    /// ```ts
+    /// const str = 'hello';
+    /// if (str) {
+    ///   console.log('string');
+    /// }
+    ///
+    /// const num = 42;
+    /// if (num) {
+    ///   console.log('number');
+    /// }
+    ///
+    /// const obj = { foo: 'bar' };
+    /// if (obj) {
+    ///   console.log('object');
+    /// }
+    ///
+    /// declare const maybeString: string | undefined;
+    /// if (maybeString) {
+    ///   console.log(maybeString);
+    /// }
+    ///
+    /// const result = str && num;
+    /// const ternary = str ? 'yes' : 'no';
+    /// ```
+    ///
+    /// Examples of **correct** code for this rule:
+    /// ```ts
+    /// const str = 'hello';
+    /// if (str !== '') {
+    ///   console.log('string');
+    /// }
+    ///
+    /// const num = 42;
+    /// if (num !== 0) {
+    ///   console.log('number');
+    /// }
+    ///
+    /// const obj = { foo: 'bar' };
+    /// if (obj !== null) {
+    ///   console.log('object');
+    /// }
+    ///
+    /// declare const maybeString: string | undefined;
+    /// if (maybeString !== undefined) {
+    ///   console.log(maybeString);
+    /// }
+    ///
+    /// const bool = true;
+    /// if (bool) {
+    ///   console.log('boolean');
+    /// }
+    /// ```
+    StrictBooleanExpressions(tsgolint),
+    typescript,
+    pedantic,
+    pending,
+);
+
+impl Rule for StrictBooleanExpressions {}