feat(eslint-plugin): add strict-type-predicates

packages/eslint-plugin/README.md

@@ -167,6 +167,7 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int
 | [`@typescript-eslint/semi`](./docs/rules/semi.md)                                                         | Require or disallow semicolons instead of ASI                                                                                                       |                    | :wrench: |                   |
 | [`@typescript-eslint/space-before-function-paren`](./docs/rules/space-before-function-paren.md)           | Enforces consistent spacing before function parenthesis                                                                                             |                    | :wrench: |                   |
 | [`@typescript-eslint/strict-boolean-expressions`](./docs/rules/strict-boolean-expressions.md)             | Restricts the types allowed in boolean expressions                                                                                                  |                    |          | :thought_balloon: |
+| [`@typescript-eslint/strict-type-predicates`](./docs/rules/strict-type-predicates.md)                     | Disallow always true (or false) type predicates                                                                                                     |                    |          | :thought_balloon: |
 | [`@typescript-eslint/triple-slash-reference`](./docs/rules/triple-slash-reference.md)                     | Sets preference level for triple slash directives versus ES6-style import declarations                                                              | :heavy_check_mark: |          |                   |
 | [`@typescript-eslint/type-annotation-spacing`](./docs/rules/type-annotation-spacing.md)                   | Require consistent spacing around type annotations                                                                                                  | :heavy_check_mark: | :wrench: |                   |
 | [`@typescript-eslint/typedef`](./docs/rules/typedef.md)                                                   | Requires type annotations to exist                                                                                                                  |                    |          |                   |

packages/eslint-plugin/ROADMAP.md

@@ -97,7 +97,7 @@ It lists all TSLint rules along side rules from the ESLint ecosystem that are th
 | [`radix`]                            | 🌟  | [`radix`][radix]                                                      |
 | [`restrict-plus-operands`]           | ✅  | [`@typescript-eslint/restrict-plus-operands`]                         |
 | [`strict-boolean-expressions`]       | ✅  | [`@typescript-eslint/strict-boolean-expressions`]                     |
-| [`strict-type-predicates`]           | 🛑  | N/A                                                                   |
+| [`strict-type-predicates`]           | ✅  | [`@typescript-eslint/strict-type-predicates`]                         |
 | [`switch-default`]                   | 🌟  | [`default-case`][default-case]                                        |
 | [`triple-equals`]                    | 🌟  | [`eqeqeq`][eqeqeq]                                                    |
 | [`typeof-compare`]                   | 🌟  | [`valid-typeof`][valid-typeof]                                        |

packages/eslint-plugin/docs/rules/strict-type-predicates.md

@@ -0,0 +1,56 @@
+# Disallow always true (or false) type predicates (`strict-type-predicates`)
+
+Warns for type predicates that are always true or always false. Works for
+`typeof` comparisons to constants (e.g. `typeof foo === 'string'`), and equality
+comparison to `null`/`undefined`. (TypeScript won’t let you compare `1 === 2`,
+but it has an exception for `1 === undefined`.) Does not yet work for
+`instanceof`. Does not warn for `if (x.y)` where `x.y` is always truthy. For
+that, see [`strict-boolean-expressions`](./strict-boolean-expressions.md).
+
+This rule requires `strictNullChecks` to be enabled.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const numberOrNull: number | null = 0;
+// Implicitly checks for `!== undefined`, which is always false.
+if (numberOrNull != null) {
+  return;
+}
+
+const numberOrUndefined: number | undefined = 0;
+// Implicitly checks for `!== null`, which is always false.
+if (numberOrNull != undefined) {
+  return;
+}
+
+const number: number = 0;
+// Always false.
+if (typeof number === 'string') {
+  return;
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const numberOrNull: number | null = 0;
+if (numberOrNull !== null) {
+  return;
+}
+
+const numberOrUndefined: number | undefined = 0;
+if (numberOrNull !== undefined) {
+  return;
+}
+
+const number: number = 0;
+// Always false.
+if (typeof number === 'number') {
+  return;
+}
+```
+
+## Related To
+
+- TSLint: [strict-type-predicates](https://palantir.github.io/tslint/rules/strict-type-predicates)

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

@@ -90,6 +90,7 @@
     "space-before-function-paren": "off",
     "@typescript-eslint/space-before-function-paren": "error",
     "@typescript-eslint/strict-boolean-expressions": "error",
+    "@typescript-eslint/strict-type-predicates": "error",
     "@typescript-eslint/triple-slash-reference": "error",
     "@typescript-eslint/type-annotation-spacing": "error",
     "@typescript-eslint/typedef": "error",

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

@@ -70,6 +70,7 @@ import returnAwait from './return-await';
 import semi from './semi';
 import spaceBeforeFunctionParen from './space-before-function-paren';
 import strictBooleanExpressions from './strict-boolean-expressions';
+import strictTypePredicates from './strict-type-predicates';
 import tripleSlashReference from './triple-slash-reference';
 import typeAnnotationSpacing from './type-annotation-spacing';
 import typedef from './typedef';
@@ -149,6 +150,7 @@ export default {
   semi: semi,
   'space-before-function-paren': spaceBeforeFunctionParen,
   'strict-boolean-expressions': strictBooleanExpressions,
+  'strict-type-predicates': strictTypePredicates,
   'triple-slash-reference': tripleSlashReference,
   'type-annotation-spacing': typeAnnotationSpacing,
   typedef: typedef,