Mar 24, 2025 · Feb 21, 2025 · Feb 25, 2025 · Feb 25, 2025 · Feb 25, 2025 · Feb 26, 2025
diff --git a/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx b/packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx
 - An `||` operator with `??`
 - An `||=` operator with `??=`
 - Ternary expressions (`?:`) that are equivalent to `||` or `??` with `??`
 - Assignment expressions (`=`) that can be safely replaced by `??=`

 ## Examples

 <Tabs>
 <TabItem value="❌ Incorrect">

 ```ts
 declare const a: string | null;
 declare const b: string | null;

 const c = a || b;

 declare let foo: { a: string } | null;
 declare function makeFoo(): { a: string };

 function lazyInitializeFooByTruthiness() {
  if (!foo) {
    foo = makeFoo();
  }
 }

 function lazyInitializeFooByNullCheck() {
  if (foo == null) {
    foo = makeFoo();
  }
 }
 ```

 </TabItem>
 <TabItem value="✅ Correct">

 ```ts
 declare const a: string | null;
 declare const b: string | null;

 const c = a ?? b;

 declare let foo: { a: string } | null;
 declare function makeFoo(): { a: string };

 function lazyInitializeFoo() {
  foo ??= makeFoo();
 }
 ```

 </TabItem>
 </Tabs>

 :::caution
 This rule will not work as expected if [`strictNullChecks`](https://www.typescriptlang.org/tsconfig#strictNullChecks) is not enabled.

 - [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
 - [Nullish Coalescing Operator Proposal](https://github.com/tc39/proposal-nullish-coalescing/)
 - [`logical-assignment-operators`](https://eslint.org/docs/latest/rules/logical-assignment-operators)
diff --git a/packages/eslint-plugin/src/rules/consistent-type-exports.ts b/packages/eslint-plugin/src/rules/consistent-type-exports.ts
        // Cache the first encountered exports for the package. We will need to come
        // back to these later when fixing the problems.
        if (node.exportKind === 'type') {
          if (sourceExports.typeOnlyNamedExport == null) {
            // The export is a type export
            sourceExports.typeOnlyNamedExport = node;
          }
        } else if (sourceExports.valueOnlyNamedExport == null) {
          // The export is a type export
          sourceExports.typeOnlyNamedExport ??= node;
        } else {
          // The export is a value export
          sourceExports.valueOnlyNamedExport = node;
          sourceExports.valueOnlyNamedExport??= node;
        }

        // Next for the current export, we will separate type/value specifiers.
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-return.ts b/packages/eslint-plugin/src/rules/no-unsafe-return.ts
        ts.isArrowFunction(functionTSNode)
          ? getContextualType(checker, functionTSNode)
          : services.getTypeAtLocation(functionNode);
      if (!functionType) {
        functionType = services.getTypeAtLocation(functionNode);
      }
      functionType ??= services.getTypeAtLocation(functionNode);
      const callSignatures = tsutils.getCallSignaturesOfType(functionType);
      // If there is an explicit type annotation *and* that type matches the actual
      // function return type, we shouldn't complain (it's intentional, even if unsafe)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -17,6 +17,54 @@ This rule reports when you may consider replacing:
		- An `\|\|` operator with `??`
		- An `\|\|=` operator with `??=`
		- Ternary expressions (`?:`) that are equivalent to `\|\|` or `??` with `??`
		- Assignment expressions (`=`) that can be safely replaced by `??=`

		## Examples
OlivierZal marked this conversation as resolved. Show resolvedHide resolved

		<Tabs>
		<TabItem value="❌ Incorrect">

		```ts
		declare const a: string \| null;
		declare const b: string \| null;

		const c = a \|\| b;

		declare let foo: { a: string } \| null;
		declare function makeFoo(): { a: string };

		function lazyInitializeFooByTruthiness() {
		if (!foo) {
		foo = makeFoo();
		}
		}

		function lazyInitializeFooByNullCheck() {
		if (foo == null) {
		foo = makeFoo();
		}
		}
		```

		</TabItem>
		<TabItem value="✅ Correct">

		```ts
		declare const a: string \| null;
		declare const b: string \| null;

		const c = a ?? b;

		declare let foo: { a: string } \| null;
		declare function makeFoo(): { a: string };

		function lazyInitializeFoo() {
		foo ??= makeFoo();
		}
		```

		</TabItem>
		</Tabs>

		:::caution
		This rule will not work as expected if [`strictNullChecks`](https://www.typescriptlang.org/tsconfig#strictNullChecks) is not enabled.
Expand DownExpand Up		@@ -255,3 +303,4 @@ If you are not using TypeScript 3.7 (or greater), then you will not be able to u

		- [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
		- [Nullish Coalescing Operator Proposal](https://github.com/tc39/proposal-nullish-coalescing/)
		- [`logical-assignment-operators`](https://eslint.org/docs/latest/rules/logical-assignment-operators)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -203,13 +203,11 @@ export default createRule<Options, MessageIds>({
		// Cache the first encountered exports for the package. We will need to come
		// back to these later when fixing the problems.
		if (node.exportKind === 'type') {
		if (sourceExports.typeOnlyNamedExport == null) {
		// The export is a type export
		sourceExports.typeOnlyNamedExport = node;
		}
		} else if (sourceExports.valueOnlyNamedExport == null) {
		// The export is a type export
		sourceExports.typeOnlyNamedExport ??= node;
OlivierZal marked this conversation as resolved. Show resolvedHide resolved
		} else {
		// The export is a value export
		sourceExports.valueOnlyNamedExport = node;
		sourceExports.valueOnlyNamedExport??= node;
OlivierZal marked this conversation as resolved. Show resolvedHide resolved
		}

		// Next for the current export, we will separate type/value specifiers.
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -80,9 +80,7 @@ export default createRule({
		ts.isArrowFunction(functionTSNode)
		? getContextualType(checker, functionTSNode)
		: services.getTypeAtLocation(functionNode);
		if (!functionType) {
		functionType = services.getTypeAtLocation(functionNode);
		}
		functionType ??= services.getTypeAtLocation(functionNode);
OlivierZal marked this conversation as resolved. Show resolvedHide resolved
		const callSignatures = tsutils.getCallSignaturesOfType(functionType);
		// If there is an explicit type annotation and that type matches the actual
		// function return type, we shouldn't complain (it's intentional, even if unsafe)
Expand Down