.changeset/lazy-animals-burn.md (1)

5-6: Polish the changeset: trailing period, locale‑neutral docs link, and add a tiny example.

Keeps release notes crisp and consistent with the repo’s conventions.

-Fixed [#7212](https://github.com/biomejs/biome/issues/7212), now the [`useOptionalChain`](https://biomejs.dev/ja/linter/rules/use-optional-chain/) rule recognizes optional chaining using `typeof` (e.g., `typeof foo !== 'undefined' && foo.bar`).
+Fixed [#7212](https://github.com/biomejs/biome/issues/7212), now the [`useOptionalChain`](https://biomejs.dev/linter/rules/use-optional-chain/) rule recognizes optional chaining using `typeof` (e.g., `typeof foo !== 'undefined' && foo.bar`).
+
+#### Example
+
+```ts
+// Before
+typeof foo !== "undefined" && foo.bar;
+// After
+foo?.bar;
+```

crates/biome_js_analyze/tests/specs/complexity/useOptionalChain/yoda_expressions_validCases.ts (1)

46-48: Add parenthesised Yoda variants to harden parsing/normalisation.

Catches spacing/precedence quirks while remaining “valid” (always true) guards.

 undefined !== typeof foo && foo.bar;
 undefined != typeof foo && foo.bar;
+ (undefined !== typeof foo) && foo.bar;
+ (undefined != typeof foo) && foo.bar;

crates/biome_js_analyze/tests/specs/complexity/useOptionalChain/validCases.ts (1)

46-48: Mirror with parenthesised typeof variants (also always true).

Prevents accidental regressions in token handling.

 typeof foo !== undefined && foo.bar;
 typeof foo != undefined && foo.bar;
+ (typeof foo !== undefined) && foo.bar;
+ (typeof foo != undefined) && foo.bar;

crates/biome_js_analyze/tests/specs/complexity/useOptionalChain/typeofLogicalAndCases1.ts (1)

1-8: Add a couple of parenthesised forms for lhs evaluation variance.

These help ensure we don’t overfit to a specific token layout.

 typeof foo !== 'undefined' && foo.bar;
 typeof foo.bar !== 'undefined' && foo.bar.baz;
+ (typeof foo !== 'undefined') && foo.bar;
+ typeof (foo) !== 'undefined' && foo();

crates/biome_js_analyze/tests/specs/complexity/useOptionalChain/typeofLogicalAndCases2.ts (1)

1-8: Non‑strict variants: add parenthesised forms too.

Keeps parity with the strict set and exercises parser edges.

 typeof foo != 'undefined' && foo.bar;
 typeof foo.bar != 'undefined' && foo.bar.baz;
+ (typeof foo != 'undefined') && foo.bar;
+ typeof (foo) != 'undefined' && foo();

crates/biome_js_analyze/tests/specs/complexity/useOptionalChain/yoda_expressions_typeofLogicalAndCases2.ts (1)

1-54: Great Yoda-style coverage; add a few parenthesised operands.

To guard against regressions when users wrap the typeof operand, add variants with parentheses.

+// parenthesised typeof operands
+'undefined' != typeof (foo) && foo.bar;
+'undefined' != typeof (foo.bar) && foo.bar.baz;
+'undefined' != typeof (foo[bar]) && foo[bar].baz;

crates/biome_js_analyze/tests/specs/complexity/useOptionalChain/yoda_expressions_typeofLogicalAndCases1.ts (1)

1-54: Solid set; mirror strict-inequality cases with parentheses.

Parity with the loose-inequality fixture helps. Add parenthesised forms.

+// parenthesised typeof operands
+'undefined' !== typeof (foo) && foo.bar;
+'undefined' !== typeof (foo.bar) && foo.bar.baz;
+'undefined' !== typeof (foo[bar]) && foo[bar].baz;

crates/biome_js_syntax/src/expr_ext.rs (3)

349-391: Minor simplification opportunity in nullish extractor.

The two branches can be expressed as an XOR, returning the non-nullish side. Purely cosmetic.

-        let left_is_nullish = is_nullish(left);
-        let right_is_nullish = is_nullish(right);
-        // right only nullish: `foo !== undefined` -> return foo (left)
-        if !left_is_nullish && right_is_nullish {
-            return Ok(Some(left.clone()));
-        }
-        // left only nullish: `undefined !== foo` -> return foo (right)
-        if left_is_nullish && !right_is_nullish {
-            return Ok(Some(right.clone()));
-        }
+        let left_is_nullish = is_nullish(left);
+        let right_is_nullish = is_nullish(right);
+        if left_is_nullish ^ right_is_nullish {
+            return Ok(Some(if left_is_nullish { right.clone() } else { left.clone() }));
+        }

---

392-404: Docs: replace smart quotes with ASCII quotes.

The example line uses a curly quote, which isn’t valid JS and may confuse readers.

-    /// ”undefined” != typeof foo;  // -> Some(foo)
+    /// "undefined" != typeof foo;  // -> Some(foo)

---

414-422: Normalise typeof argument by stripping parentheses.

Returning the unparenthesised argument avoids spurious mismatches downstream.

-        fn typeof_argument(expression: &AnyJsExpression) -> SyntaxResult<Option<AnyJsExpression>> {
+        fn typeof_argument(expression: &AnyJsExpression) -> SyntaxResult<Option<AnyJsExpression>> {
             if let Some(unary) = expression.as_js_unary_expression() {
                 return Ok(match unary.operator()? {
-                    JsUnaryOperator::Typeof => Some(unary.argument()?),
+                    JsUnaryOperator::Typeof => {
+                        let arg = unary.argument()?;
+                        Some(arg.omit_parentheses())
+                    }
                     _ => None,
                 });
             }
             Ok(None)
         }

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/src/**/*.rs : Use TypeData::Unknown for unimplemented inference and TypeData::UnknownKeyword for the explicit TypeScript unknown keyword; treat them semantically the same but keep them distinct for measurement