fix(eslint-plugin): [prefer-optional-chain] include mixed "nullish comparison style" chains in checks #11533

mdm317 · 2025-08-27T14:55:13Z

PR Checklist

Addresses an existing open issue: fixes [prefer-optional-chain] include mixed "nullish comparison style" chains in checks #7170
Also fixes Bug: [prefer-optional-chain] Unsoundly fixes a !== undefined && a.b !== null to a?.b !== null #10484 to not report that case.
That issue was marked as accepting prs
Steps in Contributing were taken
Also fixes Bug: [prefer-optional-chain] Unsoundly fixes a !== undefined && a.b !== null to a?.b !== null #10484 not report that case

Overview

"boolean" checks (eg foo and !foo)
!==/===/!=/== comparing against anything except typeof
not typeof because foo && typeof foo.bar will return undefined | typeof foo.bar whereas typeof foo?.bar will return typeof foo.bar | 'undefined' - which is VERY different
should not include >/>=/</<= because TS will hard error if one of the operands is nullish.

In this PR, I decided not to include boolean checks within optional chaining.
The reason is that the boolean outcome may differ between the original code and the optional chaining, which may lead to type inference issues (for example, as described in issue 7654

foo && !foo.bar
if( foo && !foo.bar ){
// foo can't nullish
}
if( !foo?.bar ){
// foo can nullisth
}

So I only handle equality operators (==, ===, !=, !==) at the end of a chain, and only when the boolean result is unchanged after converting to optional chaining.

Algorithm
AND (&&) versions

Expression	LHS (`a != null && …`)	RHS (`a?.b …`)	Equal if…
a != null && a.b != somevalue ↔ a?.b != somevalue	false	undefined != somevalue	somevalue == null (`null` or `undefined`)
a != null && a.b !== somevalue ↔ a?.b !== somevalue	false	undefined !== somevalue	somevalue === undefined
a != null && a.b == somevalue ↔ a?.b == somevalue	false	undefined == somevalue	somevalue != null
a != null && a.b === somevalue ↔ a?.b === somevalue	false	undefined === somevalue	somevalue !== undefined

OR (||) versions

Expression	LHS (`a == null \|\| …`)	RHS (`a?.b …`)	Equal if…
a == null \|\ a.b != somevalue ↔ a?.b != somevalue	true	undefined != somevalue	somevalue != null
a == null \|\| a.b !== somevalue ↔ a?.b !== somevalue	true	undefined !== somevalue	somevalue !== undefined
a == null \|\| a.b == somevalue ↔ a?.b == somevalue	true	undefined == somevalue	somevalue == null
a == null \|\| a.b === somevalue ↔ a?.b === somevalue	true	undefined === somevalue	somevalue === undefined

Test cases

Valid (no report)

We do not report when converting to optional chaining could change runtime behavior — especially with truthy/falsy values.
Example from issue 7654:

const data: Data | null = getData();

// Both: `data` must be truthy AND `data.value` not null (0 is valid)
if (data && data.value !== null) {
  console.log("Number: " + data.value);
} else {
  console.log("Invalid data.");
}

Error

Conversion to optional chaining either produces the same result as before, or introduces a type allowed by optional chaining.

foo != null && foo.bar
foo?.bar

Suggestion

Optional chaining introduces an additional undefined type, which changes the result type but preserves the same truthy/falsy behavior.

declare const foo: { bar: number } | null | undefined;
foo != undefined && foo.bar;         => false | number
foo?.bar                                           => undefined | number

Currently, even when the type changes, especially truthy and false some cases report as a suggestion.
examples

declare const foo : { bar : number | null } | null

foo == null || foo.bar === null    => true when foo is null
foo?.bar === null                         => false when foo is null

I think we should fix these cases not to be reported as suggestions.
repro

…perator consistency based on logical operator - When parent operator is `&&`, enforce `==` or `===` as the last operand operator. - When parent operator is `||`, enforce `!=` or `!==` as the last operand operator.

- Already check isTruthyOperand and isValidLastChainOperand so dowmstream error not occur when ComparisonType - And !==, != check not nullish

some occur in chain when != null is last chain typescript-eslint#7654

a != null && a.b != null a?.b != null always same when a != null is true

a !== undefined && a.b a?.b always same when a is not nullish

a || b is always b when a is false

typescript-eslint · 2025-08-27T14:55:17Z

Thanks for the PR, @mdm317!

typescript-eslint is a 100% community driven project, and we are incredibly grateful that you are contributing to that community.

The core maintainers work on this in their personal time, so please understand that it may not be possible for them to review your work immediately.

Thanks again!

🙏 Please, if you or your company is finding typescript-eslint valuable, help us sustain the project by sponsoring it transparently on https://opencollective.com/typescript-eslint.

netlify · 2025-08-27T14:55:19Z

✅ Deploy Preview for typescript-eslint ready!

Name	Link
🔨 Latest commit	`f8e07cf`
🔍 Latest deploy log	https://app.netlify.com/projects/typescript-eslint/deploys/68dfc31c2d4ed3000800114c
😎 Deploy Preview	https://deploy-preview-11533--typescript-eslint.netlify.app
📱 Preview on mobile	Toggle QR Code... Use your smartphone camera to open QR code link.
Lighthouse	1 paths audited Performance: 99 (🟢 up 21 from production) Accessibility: 97 (no change from production) Best Practices: 100 (no change from production) SEO: 92 (no change from production) PWA: 80 (no change from production) View the detailed breakdown and full score reports

To edit notification comments on pull requests, go to your Netlify project configuration.

nx-cloud · 2025-08-27T14:56:25Z

🤖 Nx Cloud AI Fix Eligible

An automatically generated fix could have helped fix failing tasks for this run, but Self-healing CI is disabled for this workspace. Visit workspace settings to enable it and get automatic fixes in future runs.

_{To disable these notifications, a workspace admin can disable them in workspace settings.}

View your CI Pipeline Execution ↗ for commit f8e07cf

Command	Status	Duration	Result
`nx run-many -t typecheck`	❌ Failed	2m 2s	View ↗
`nx test eslint-plugin --coverage=false`	✅ Succeeded	5m 13s	View ↗
`nx test typescript-estree --coverage=false`	✅ Succeeded	2s	View ↗
`nx test eslint-plugin-internal --coverage=false`	✅ Succeeded	3s	View ↗
`nx run types:build`	✅ Succeeded	5s	View ↗
`nx run integration-tests:test`	✅ Succeeded	4s	View ↗
`nx run generate-configs`	✅ Succeeded	6s	View ↗
`nx run-many --target=build --parallel --exclude...`	✅ Succeeded	16s	View ↗
`Additional runs (28)`	✅ Succeeded	...	View ↗

☁️ Nx Cloud last updated this comment at 2025-10-03 12:48:53 UTC

…perators

codecov · 2025-09-04T11:57:28Z

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 90.78%. Comparing base (cdd6384) to head (f8e07cf).
⚠️ Report is 14 commits behind head on main.

Additional details and impacted files

@@            Coverage Diff             @@
##             main   #11533      +/-   ##
==========================================
+ Coverage   90.74%   90.78%   +0.04%     
==========================================
  Files         516      516              
  Lines       51989    52222     +233     
  Branches     8588     8646      +58     
==========================================
+ Hits        47176    47409     +233     
  Misses       4799     4799              
  Partials       14       14

Flag	Coverage Δ
unittest	`90.78% <100.00%> (+0.04%)`	⬆️

Flags with carried forward coverage won't be shown. Click here to find out more.

Files with missing lines	Coverage Δ
...kages/eslint-plugin/src/rules/no-base-to-string.ts	`99.06% <ø> (ø)`
...ackages/eslint-plugin/src/rules/prefer-includes.ts	`98.16% <100.00%> (ø)`
.../rules/prefer-optional-chain-utils/analyzeChain.ts	`100.00% <100.00%> (ø)`
...efer-optional-chain-utils/gatherLogicalOperands.ts	`100.00% <100.00%> (ø)`
...s/eslint-plugin/src/rules/prefer-optional-chain.ts	`100.00% <100.00%> (ø)`
...plugin/src/rules/prefer-string-starts-ends-with.ts	`98.82% <100.00%> (ø)`

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

check lastOperand always evaluates to true cases: - case `!= null` - case `!== null && !== undefined`

mdm317 · 2025-09-05T14:35:52Z

packages/eslint-plugin/src/rules/no-base-to-string.ts

+      // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
      if (declarations == null || declarations.length !== 1) {


const declarations: ts.Declaration[] | undefined

When the new logic was applied, this code
declarations == null || declarations.length !== 1
was changed to
declarations?.length !== 1

But I think the original code is more readable and intuitive.
For cases like foo == null || <equaliy check>, should we avoid optional chaining?
What do you think?
example new playground

If the choices are these:

Original: if (declations == null || declations.length !== 1) {

Updated: if (declations?.length !== 1) {

Personal anecodtal thoughts: I find the updated form more readable. I think when ?. was new I would probably have preferred the original for being more familiar. But at this point I'm pretty comfortable with ?. and ??, and it feels natural to me.

mdm317 · 2025-09-05T15:31:36Z

packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts

  return false;
 }

+function isAlwaysTruthyOperand(


I'm not convinced this function is necessary.
This function checks if the previous operand is always true:

foo != null && foo.bar == somevalue → foo?.bar == somevalue (same result when foo is not nullish)

foo && foo.bar == somevalue → foo?.bar == somevalue (same result when foo is truthy)

But if we know foo is not nullish, we can simply write foo.bar == somevalue without optional chaining at all.

Removing it fails some unit tests (that have legitimate cases, I believe). E.g.:

declare const foo: { bar: string } | null; foo !== null && foo.bar !== null;

mdm317 · 2025-09-05T15:49:54Z

packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts

  chain,
 ) => {
  switch (operand.comparisonType) {
-    case NullishComparisonType.Boolean: {


This logic moved to line 700.

Thanks for these tips, they made reviewing this (already, by necessity, complex) logic easier. 🙂

mdm317 · 2025-09-05T16:19:17Z

packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts

+          case NullishComparisonType.StrictEqualNull:
+          case NullishComparisonType.NotStrictEqualNull: {


When the last parameter is StrictEqualNull like foo && foo.bar !== null, we can't convert to optional chaining because:

foo && foo.bar !== null returns false when foo is nullish

foo?.bar !== null returns true when foo is nullish

Also StrictEqualNull case foo == null | foo.bar !== null

foo == null || foo.bar !== null returns true when foo is nullish

foo?.bar !== null returns false when foo is nullish

This issue is documented here.

But as I mentioned above, I'm still curious whether this logic is necessary at all.

mdm317 · 2025-09-05T16:31:36Z

packages/eslint-plugin/src/rules/prefer-optional-chain-utils/analyzeChain.ts

+        lastOperand.comparisonType,
+        parserServices,
+      ) ||
+        isValidLastChainOperand(


This function checks if the last operand is valid as outlined in the table.

mdm317 · 2025-09-05T16:36:30Z

packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts

+      left.type === AST_NODE_TYPES.MemberExpression;
+    const isRightMemberExpression =
+      right.type === AST_NODE_TYPES.MemberExpression;
+    if (isLeftMemberExpression && !isRightMemberExpression) {


Only checks MemberExpression because equality checks cannot be the first chain element.

mdm317 · 2025-09-05T16:46:34Z

packages/eslint-plugin/tests/rules/prefer-optional-chain/prefer-optional-chain.test.ts

+                    | null
+                    | undefined;
+                };
+                foo.bar?.() !== null &&


If foo.bar is guaranteed to be non-nullish, we can change it to optional chaining.

mdm317 · 2025-09-05T16:49:43Z

packages/eslint-plugin/tests/rules/prefer-optional-chain/prefer-optional-chain.test.ts

+                    | undefined;
+                };
+                foo.bar === undefined ||
+                  foo.bar() === undefined ||


Since operand is a nullish check,
operand || foo.bar() === undefined can be converted to optional chaining.

JoshuaKGoldberg

I have to be honest, this rule is one of my least favorites to review -- purely because of how intricate and nuanced its logic is. Each time I review I think I get to maybe 80% comprehension of it. Very Pareto Principle. If someone like @bradzacher has time to take a deeper look that'd probably be best... but the rule is quite well-tested, and from what I had time to parse out this is excellent.

I have no suggestions for changes. Just the one request to remove an eslint-disable internally as you'd brought a comment up on.

Awesome work. Really, thank you for diving so much into this beast of a rule! 🔥

JoshuaKGoldberg · 2025-10-03T12:42:24Z

packages/eslint-plugin/src/rules/no-base-to-string.ts

+      // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
      if (declarations == null || declarations.length !== 1) {


If the choices are these:

Original: if (declations == null || declations.length !== 1) {

Updated: if (declations?.length !== 1) {

Personal anecodtal thoughts: I find the updated form more readable. I think when ?. was new I would probably have preferred the original for being more familiar. But at this point I'm pretty comfortable with ?. and ??, and it feels natural to me.

JoshuaKGoldberg · 2025-10-03T12:42:47Z

packages/eslint-plugin/tests/rules/prefer-optional-chain/prefer-optional-chain.test.ts

[Praise] Such thorough testing! Lovely. 👏 🔥

JoshuaKGoldberg · 2025-10-03T12:53:26Z

packages/eslint-plugin/src/rules/prefer-optional-chain-utils/gatherLogicalOperands.ts

+        // x == something :(
+        // x === something :(
+        // x != something :(
+        // x !== something :(


[Praise] The :(s made me chuckle. 😄

B4nan · 2025-10-14T08:02:41Z

This PR is too aggressive and suggests optional chaining in cases where it would change behavior.

Few cases from mikro-orm/mikro-orm#6924 (when applying the suggested fixes, the better half of the test suite breaks).

-    if (meta.properties[propertyName] && meta.properties[propertyName].kind !== reference) {
+    if (meta.properties[propertyName]?.kind !== reference) {

-    if (!meta.embeddable && (!meta.primaryKeys || meta.primaryKeys.length === 0)) {
+    if (!meta.embeddable && (meta.primaryKeys?.length === 0)) {

-      if (!prop.ownColumns || prop.ownColumns.length === 0) {
+      if (prop.ownColumns?.length === 0) {

-    if (!last || last[0] !== entityName || last[1] !== prop) {
+    if (last?.[0] !== entityName || last[1] !== prop) {

Basically, all the changes that the PR suggests are wrong.

kirkwaiblinger · 2025-10-14T09:03:45Z

@B4nan We ask that you please file a new issue rather than commenting on a closed PR, see https://typescript-eslint.io/contributing/issues#commenting.

I'm not able to reproduce what you're seeing in the playground based on my best guess at creating a reproduction... This code does not result in a lint report:

(playground)

declare const a: { b?: number[] };

if (!a.b || a.b.length === 0) {
  
}

Can you please help us help you by creating an isolated reproduction we can try, and filing a new issue with it? Thanks!

aboks · 2025-10-14T12:39:01Z

We also observe overly 'aggresive' behavior from this rule, as described in the comment by @B4nan. I've opened #11700 with a reproduction case.

| datasource | package | from | to | | ---------- | -------------------------------- | ------ | ------ | | npm | @typescript-eslint/eslint-plugin | 8.46.0 | 8.46.1 | | npm | @typescript-eslint/parser | 8.46.0 | 8.46.1 | ## [v8.46.1](https://github.com/typescript-eslint/typescript-eslint/blob/HEAD/packages/eslint-plugin/CHANGELOG.md#8461-2025-10-13) ##### 🩹 Fixes - **eslint-plugin:** \[no-misused-promises] special-case `.finally` not to report when a promise returning function is provided as an argument ([#11667](typescript-eslint/typescript-eslint#11667)) - **eslint-plugin:** \[prefer-optional-chain] include mixed "nullish comparison style" chains in checks ([#11533](typescript-eslint/typescript-eslint#11533)) ##### ❤️ Thank You - mdm317 - Ronen Amiel You can read about our [versioning strategy](https://typescript-eslint.io/users/versioning) and [releases](https://typescript-eslint.io/users/releases) on our website.

mdm317 added 12 commits August 26, 2025 14:44

test: add default test

cfdd536

feat: comparison operators at the end of optional chains

33e6c71

fix : suggestion

3aa3b04

- Already check isTruthyOperand and isValidLastChainOperand so dowmstream error not occur when ComparisonType - And !==, != check not nullish

fix : != null is last chain

51d956f

some occur in chain when != null is last chain typescript-eslint#7654

text: change basecases

8c3de3a

a != null && a.b != null a?.b != null always same when a != null is true

test: change !== undefined base cases

5987dfc

a !== undefined && a.b a?.b always same when a is not nullish

test: when !== undefined is last chain

bd5d289

test: add some union case

15b7fc8

test: add base case in || operator

7ffa803

fix : test case

df6809a

a || b is always b when a is false

feat : or chain

165e914

mdm317 added 4 commits September 3, 2025 15:56

refactoring: change funtion name

b7d2e02

Merge branch 'main' into feat/prefer-optional-chain-with-comparison-o…

2adc3da

…perators

lint

7fe1f33

lint

90c13fa

mdm317 marked this pull request as draft September 4, 2025 09:02

chore: new readme shot

609d1aa

mdm317 and others added 6 commits September 5, 2025 02:36

Refactor

9aa435a

test: add missing case, and chain when the last chain is != operand

befd7a0

test: yoda case when & chain

c59f77f

add missing logic

aa793f2

test : add missing case

2a5798b

check lastOperand always evaluates to true cases: - case `!= null` - case `!== null && !== undefined`

add missing case

f71611f

mdm317 commented Sep 5, 2025

View reviewed changes

mdm317 marked this pull request as ready for review September 8, 2025 04:43

Merge branch 'main'

f8e07cf

JoshuaKGoldberg approved these changes Oct 3, 2025

View reviewed changes

JoshuaKGoldberg added the 1 approval >=1 team member has approved this PR; we're now leaving it open for more reviews before we merge label Oct 3, 2025

bradzacher approved these changes Oct 7, 2025

View reviewed changes

bradzacher merged commit 73003bf into typescript-eslint:main Oct 7, 2025
65 of 67 checks passed

chrisbbreuer mentioned this pull request Oct 13, 2025

chore(deps): update all non-major dependencies stacksjs/eslint-plugin#67

Open

1 task

fossabot bot mentioned this pull request Oct 14, 2025

Bump @typescript-eslint/parser from 8.46.0 to 8.46.1 fossas/fossa-action#224

Closed

aboks mentioned this pull request Oct 14, 2025

Bug: @typescript-eslint/prefer-optional-chain flags situations where an optional chain would change behavior #11700

Closed

4 tasks

mdm317 mentioned this pull request Oct 16, 2025

fix(eslint-plugin): [prefer-optional-chain] skip optional chaining when it could change the result #11702

Merged

3 tasks

This was referenced Oct 21, 2025

Bump @typescript-eslint/parser from 8.46.0 to 8.46.2 fossas/fossa-action#229

Merged

Update dependency @typescript-eslint/parser to v8.46.2 ericcornelissen/js-regex-security-scanner#1281

Closed

		// eslint-disable-next-line @typescript-eslint/prefer-optional-chain
		if (declarations == null \|\| declarations.length !== 1) {

		case NullishComparisonType.StrictEqualNull:
		case NullishComparisonType.NotStrictEqualNull: {

Uh oh!

fix(eslint-plugin): [prefer-optional-chain] include mixed "nullish comparison style" chains in checks #11533

fix(eslint-plugin): [prefer-optional-chain] include mixed "nullish comparison style" chains in checks #11533

Uh oh!

Conversation

mdm317 commented Aug 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

PR Checklist

Overview

Test cases

Valid (no report)

Error

Suggestion

Uh oh!

typescript-eslint bot commented Aug 27, 2025

Uh oh!

netlify bot commented Aug 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

✅ Deploy Preview for typescript-eslint ready!

Uh oh!

nx-cloud bot commented Aug 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

🤖 Nx Cloud AI Fix Eligible

Uh oh!

codecov bot commented Sep 4, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JoshuaKGoldberg Oct 3, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

JoshuaKGoldberg left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

B4nan commented Oct 14, 2025

Uh oh!

kirkwaiblinger commented Oct 14, 2025

Uh oh!

aboks commented Oct 14, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

6 participants

mdm317 commented Aug 27, 2025 •

edited

Loading

netlify bot commented Aug 27, 2025 •

edited

Loading

nx-cloud bot commented Aug 27, 2025 •

edited

Loading

codecov bot commented Sep 4, 2025 •

edited

Loading

JoshuaKGoldberg Oct 3, 2025 •

edited

Loading