feat(eslint-plugin): add no-non-null-asserted-nullish-coalescing rule

packages/eslint-plugin/docs/rules/no-non-null-asserted-nullish-coalescing.md

@@ -0,0 +1,49 @@
+# Disallows using a non-null assertion in the left operand of the nullish coalescing operator (`no-non-null-asserted-nullish-coalescing`)
+
+## Rule Details
+
+The nullish coalescing operator is designed to provide a default value when dealing with `null` or `undefined`.
+Using non-null assertions in the left operand of the nullish coalescing operator is redundant.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+/* eslint @typescript-eslint/no-non-null-asserted-nullish-coalescing: "error" */
+
+foo! ?? bar;
+foo.bazz! ?? bar;
+foo!.bazz! ?? bar;
+foo()! ?? bar;
+
+let x!: string;
+x! ?? '';
+
+let x: string;
+x = foo();
+x! ?? '';
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+/* eslint @typescript-eslint/no-non-null-asserted-nullish-coalescing: "error" */
+
+foo ?? bar;
+foo ?? bar!;
+foo!.bazz ?? bar;
+foo!.bazz ?? bar!;
+foo() ?? bar;
+
+// This is considered correct code because because there's no way for the user to satisfy it.
+let x: string;
+x! ?? '';
+```
+
+## When Not To Use It
+
+If you are not using TypeScript 3.7 (or greater), then you will not need to use this rule, as the operator is not supported.
+
+## Further Reading
+
+- [TypeScript 3.7 Release Notes](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html)
+- [Nullish Coalescing Proposal](https://github.com/tc39/proposal-nullish-coalescing)

packages/eslint-plugin/src/configs/all.ts

@@ -81,6 +81,7 @@ export = {
     '@typescript-eslint/no-misused-new': 'error',
     '@typescript-eslint/no-misused-promises': 'error',
     '@typescript-eslint/no-namespace': 'error',
+    '@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error',
     '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
     '@typescript-eslint/no-non-null-assertion': 'error',
     '@typescript-eslint/no-parameter-properties': 'error',

packages/eslint-plugin/src/rules/index.ts

@@ -53,6 +53,7 @@ import noMagicNumbers from './no-magic-numbers';
 import noMisusedNew from './no-misused-new';
 import noMisusedPromises from './no-misused-promises';
 import noNamespace from './no-namespace';
+import noNonNullAssertedNullishCoalescing from './no-non-null-asserted-nullish-coalescing';
 import noNonNullAssertedOptionalChain from './no-non-null-asserted-optional-chain';
 import noNonNullAssertion from './no-non-null-assertion';
 import noParameterProperties from './no-parameter-properties';
@@ -171,6 +172,7 @@ export default {
   'no-misused-new': noMisusedNew,
   'no-misused-promises': noMisusedPromises,
   'no-namespace': noNamespace,
+  'no-non-null-asserted-nullish-coalescing': noNonNullAssertedNullishCoalescing,
   'no-non-null-asserted-optional-chain': noNonNullAssertedOptionalChain,
   'no-non-null-assertion': noNonNullAssertion,
   'no-parameter-properties': noParameterProperties,

packages/eslint-plugin/src/rules/no-non-null-asserted-nullish-coalescing.ts

@@ -0,0 +1,94 @@
+import { TSESTree, TSESLint } from '@typescript-eslint/experimental-utils';
+import {
+  Definition,
+  DefinitionType,
+  Variable,
+} from '@typescript-eslint/scope-manager';
+import * as util from '../util';
+
+function hasAssignmentBeforeNode(
+  variable: Variable,
+  node: TSESTree.Node,
+): boolean {
+  return (
+    variable.references.some(
+      ref => ref.isWrite() && ref.identifier.range[1] < node.range[1],
+    ) ||
+    variable.defs.some(
+      def =>
+        isDefinitionWithAssignment(def) && def.node.range[1] < node.range[1],
+    )
+  );
+}
+
+function isDefinitionWithAssignment(definition: Definition): boolean {
+  if (definition.type !== DefinitionType.Variable) {
+    return false;
+  }
+
+  const variableDeclarator = definition.node;
+  return variableDeclarator.definite ?? variableDeclarator.init !== null;
+}
+
+export default util.createRule({
+  name: 'no-non-null-asserted-nullish-coalescing',
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallows using a non-null assertion in the left operand of the nullish coalescing operator',
+      category: 'Possible Errors',
+      recommended: false,
+      suggestion: true,
+    },
+    messages: {
+      noNonNullAssertedNullishCoalescing:
+        'The nullish coalescing operator is designed to handle undefined and null - using a non-null assertion is not needed.',
+      suggestRemovingNonNull: 'You should remove the non-null assertion.',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      'LogicalExpression[operator = "??"] > TSNonNullExpression.left'(
+        node: TSESTree.TSNonNullExpression,
+      ): void {
+        if (node.expression.type === TSESTree.AST_NODE_TYPES.Identifier) {
+          const scope = context.getScope();
+          const identifier = node.expression;
+          const variable = scope.set.get(identifier.name);
+          if (variable && !hasAssignmentBeforeNode(variable, node)) {
+            return;
+          }
+        }
+
+        context.report({
+          node,
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          /*
+          Use a suggestion instead of a fixer, because this can break type checks.
+          The resulting type of the nullish coalesce is only influenced by the right operand if the left operand can be `null` or `undefined`.
+          After removing the non-null assertion the type of the left operand might contain `null` or `undefined` and then the type of the right operand
+          might change the resulting type of the nullish coalesce.
+          See the following example:
+
+          function test(x?: string): string {
+            const bar = x! ?? false; // type analysis reports `bar` has type `string`
+            //          x  ?? false; // type analysis reports `bar` has type `string | false`
+            return bar;
+          }
+          */
+          suggest: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              fix(fixer): TSESLint.RuleFix {
+                return fixer.removeRange([node.range[1] - 1, node.range[1]]);
+              },
+            },
+          ],
+        });
+      },
+    };
+  },
+});