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

fixes #2853

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

@@ -0,0 +1,38 @@
+# 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;
+```
+
+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;
+```
+
+## 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,44 @@
+import { TSESTree, TSESLint } from '@typescript-eslint/experimental-utils';
+import * as util from '../util';
+
+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 {
+        context.report({
+          node,
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          // use a suggestion instead of a fixer, because this can obviously break type checks
+          suggest: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              fix(fixer): TSESLint.RuleFix {
+                return fixer.removeRange([node.range[1] - 1, node.range[1]]);
+              },
+            },
+          ],
+        });
+      },
+    };
+  },
+});

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

@@ -0,0 +1,134 @@
+import rule from '../../src/rules/no-non-null-asserted-nullish-coalescing';
+import { RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('no-non-null-asserted-nullish-coalescing', rule, {
+  valid: [
+    'foo ?? bar;',
+    'foo ?? bar!;',
+    'foo.bazz ?? bar;',
+    'foo.bazz ?? bar!;',
+    'foo!.bazz ?? bar;',
+    'foo!.bazz ?? bar!;',
+    'foo() ?? bar;',
+    'foo() ?? bar!;',
+    '(foo ?? bar)!;',
+  ],
+  invalid: [
+    {
+      code: 'foo! ?? bar;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo ?? bar;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'foo! ?? bar!;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo ?? bar!;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'foo.bazz! ?? bar;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo.bazz ?? bar;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'foo.bazz! ?? bar!;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo.bazz ?? bar!;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'foo!.bazz! ?? bar;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo!.bazz ?? bar;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'foo!.bazz! ?? bar!;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo!.bazz ?? bar!;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'foo()! ?? bar;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo() ?? bar;',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'foo()! ?? bar!;',
+      errors: [
+        {
+          messageId: 'noNonNullAssertedNullishCoalescing',
+          suggestions: [
+            {
+              messageId: 'suggestRemovingNonNull',
+              output: 'foo() ?? bar!;',
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});