reedanders
diff --git a/‎packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx
Lines changed: 49 additions & 0 deletions b/‎packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.mdx
Lines changed: 49 additions & 0 deletions
diff --git a/‎packages/eslint-plugin/src/rules/consistent-type-exports.ts
Lines changed: 4 additions & 6 deletions b/‎packages/eslint-plugin/src/rules/consistent-type-exports.ts
Lines changed: 4 additions & 6 deletions
diff --git a/‎packages/eslint-plugin/src/rules/no-unsafe-return.ts
Lines changed: 1 addition & 3 deletions b/‎packages/eslint-plugin/src/rules/no-unsafe-return.ts
Lines changed: 1 addition & 3 deletions
@@ -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
+
+<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.
@@ -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)
@@ -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;
+        } else {
           // The export is a value export
-          sourceExports.valueOnlyNamedExport = node;
+          sourceExports.valueOnlyNamedExport ??= node;
         }
 
         // Next for the current export, we will separate type/value specifiers.
 
@@ -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);
       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)