typescript-eslint · kirkwaiblinger · Mar 6, 2025 · Feb 21, 2025 · Feb 21, 2025 · Mar 3, 2025
diff --git a/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx b/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx
@@ -84,7 +84,7 @@ Examples of code for this rule with `{ ignoreConditionalTests: false }`:
 <TabItem value="❌ Incorrect">
 
 ```ts option='{ "ignoreConditionalTests": false }'
-declare const a: string | null;
+declare let a: string | null;
 declare const b: string | null;
 
 if (a || b) {
@@ -102,7 +102,7 @@ a || b ? true : false;
 <TabItem value="✅ Correct">
 
 ```ts option='{ "ignoreConditionalTests": false }'
-declare const a: string | null;
+declare let a: string | null;
 declare const b: string | null;
 
 if (a ?? b) {
@@ -133,7 +133,7 @@ Examples of code for this rule with `{ ignoreMixedLogicalExpressions: false }`:
 <TabItem value="❌ Incorrect">
 
 ```ts option='{ "ignoreMixedLogicalExpressions": false }'
-declare const a: string | null;
+declare let a: string | null;
 declare const b: string | null;
 declare const c: string | null;
 declare const d: string | null;
@@ -149,7 +149,7 @@ a || (b && c && d);
 <TabItem value="✅ Correct">
 
 ```ts option='{ "ignoreMixedLogicalExpressions": false }'
-declare const a: string | null;
+declare let a: string | null;
 declare const b: string | null;
 declare const c: string | null;
 declare const d: string | null;

diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -12,12 +12,10 @@ import {
   getTypeName,
   getTypeOfPropertyOfName,
   getValueOfLiteralType,
-  isAlwaysNullish,
   isArrayMethodCallWithPredicate,
   isIdentifier,
   isNullableType,
   isPossiblyFalsy,
-  isPossiblyNullish,
   isPossiblyTruthy,
   isTypeAnyType,
   isTypeFlagSet,
@@ -31,6 +29,25 @@ import {
 } from '../util/assertionFunctionUtils';
 
 // #region
+
+const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
+
+function isNullishType(type: ts.Type): boolean {
+  return tsutils.isTypeFlagSet(type, nullishFlag);
+}
+
+function isAlwaysNullish(type: ts.Type): boolean {
+  return tsutils.unionTypeParts(type).every(isNullishType);
+}
+
+/**
+ * Note that this differs from {@link isNullableType} in that it doesn't consider
+ * `any` or `unknown` to be nullable.
+ */
+function isPossiblyNullish(type: ts.Type): boolean {
+  return tsutils.unionTypeParts(type).some(isNullishType);
+}
+
 function toStaticValue(
   type: ts.Type,
 ):

diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -13,7 +13,7 @@ import {
   isNodeEqual,
   isNodeOfTypes,
   isNullLiteral,
-  isPossiblyNullish,
+  isNullableType,
   isUndefinedIdentifier,
   nullThrows,
   NullThrowsReasons,
@@ -193,7 +193,7 @@ export default createRule<Options, MessageIds>({
      * a nullishness check, taking into account the rule's configuration.
      */
     function isTypeEligibleForPreferNullish(type: ts.Type): boolean {
-      if (!isPossiblyNullish(type)) {
+      if (!isNullableType(type)) {
         return false;
       }
 
@@ -211,14 +211,33 @@ export default createRule<Options, MessageIds>({
       ]
         .filter((flag): flag is number => typeof flag === 'number')
         .reduce((previous, flag) => previous | flag, 0);
+
+      if (ignorableFlags === 0) {
+        // any types are eligible for conversion.
+        return true;
+      }
+
+      // if the type is `any` or `unknown` we can't make any assumptions
+      // about the value, so it could be any primitive, even though the flags
+      // won't be set.
+      //
+      // technically, this is true of `void` as well, however, it's a TS error
+      // to test `void` for truthiness, so we don't need to bother checking for
+      // it in valid code.
+      if (
+        tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)
+      ) {
+        return false;
+      }
+
       if (
-        type.flags !== ts.TypeFlags.Null &&
-        type.flags !== ts.TypeFlags.Undefined &&
-        (type as ts.UnionOrIntersectionType).types.some(t =>
-          tsutils
-            .intersectionTypeParts(t)
-            .some(t => tsutils.isTypeFlagSet(t, ignorableFlags)),
-        )
+        tsutils
+          .typeParts(type)
+          .some(t =>
+            tsutils
+              .intersectionTypeParts(t)
+              .some(t => tsutils.isTypeFlagSet(t, ignorableFlags)),
+          )
       ) {
         return false;
       }

diff --git a/packages/eslint-plugin/src/util/index.ts b/packages/eslint-plugin/src/util/index.ts
@@ -28,7 +28,7 @@ export * from './getConstraintInfo';
 export * from './getValueOfLiteralType';
 export * from './isHigherPrecedenceThanAwait';
 export * from './skipChainExpression';
-export * from './truthinessAndNullishUtils';
+export * from './truthinessUtils';
 
 // this is done for convenience - saves migrating all of the old rules
 export * from '@typescript-eslint/type-utils';

diff --git a/...gin/src/util/truthinessAndNullishUtils.ts → ...eslint-plugin/src/util/truthinessUtils.ts b/...gin/src/util/truthinessAndNullishUtils.ts → ...eslint-plugin/src/util/truthinessUtils.ts
@@ -28,14 +28,3 @@ export const isPossiblyTruthy = (type: ts.Type): boolean =>
       // like `"" & { __brand: string }`.
       intersectionParts.every(type => !tsutils.isFalsyType(type)),
     );
-
-// Nullish utilities
-const nullishFlag = ts.TypeFlags.Undefined | ts.TypeFlags.Null;
-const isNullishType = (type: ts.Type): boolean =>
-  tsutils.isTypeFlagSet(type, nullishFlag);
-
-export const isPossiblyNullish = (type: ts.Type): boolean =>
-  tsutils.unionTypeParts(type).some(isNullishType);
-
-export const isAlwaysNullish = (type: ts.Type): boolean =>
-  tsutils.unionTypeParts(type).every(isNullishType);
diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/prefer-nullish-coalescing.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/prefer-nullish-coalescing.shot