From 6718906fa83fbceb947b0ea0b7f23428b993b1d3 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <joshuakgoldberg@outlook.com>
Date: Wed, 3 Apr 2019 12:48:27 -0400
Subject: [PATCH 01/17] feat(eslint-plugin): added new rule unbound-method
 (#204)

---
 packages/eslint-plugin/README.md              |   1 +
 packages/eslint-plugin/ROADMAP.md             |   3 +-
 .../docs/rules/unbound-method.md              |  92 ++++++
 .../eslint-plugin/src/rules/unbound-method.ts | 123 ++++++++
 .../tests/rules/unbound-method.test.ts        | 273 ++++++++++++++++++
 5 files changed, 491 insertions(+), 1 deletion(-)
 create mode 100644 packages/eslint-plugin/docs/rules/unbound-method.md
 create mode 100644 packages/eslint-plugin/src/rules/unbound-method.ts
 create mode 100644 packages/eslint-plugin/tests/rules/unbound-method.test.ts

diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
index 6d433a5eef51..8057f15843d4 100644
--- a/packages/eslint-plugin/README.md
+++ b/packages/eslint-plugin/README.md
@@ -152,6 +152,7 @@ Then you should add `airbnb` (or `airbnb-base`) to your `extends` section of `.e
 | [`@typescript-eslint/promise-function-async`](./docs/rules/promise-function-async.md)                     | Requires any function or method that returns a Promise to be marked async. (`promise-function-async` from TSLint)                                   |                    |          | :thought_balloon: |
 | [`@typescript-eslint/restrict-plus-operands`](./docs/rules/restrict-plus-operands.md)                     | When adding two variables, operands must both be of type number or of type string. (`restrict-plus-operands` from TSLint)                           |                    |          | :thought_balloon: |
 | [`@typescript-eslint/type-annotation-spacing`](./docs/rules/type-annotation-spacing.md)                   | Require consistent spacing around type annotations (`typedef-whitespace` from TSLint)                                                               | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/unbound-method`](./docs/rules/unbound-method.md)                                     | Enforces unbound methods are called with their expected scope. (`no-unbound-method` from TSLint)                                                    | :heavy_check_mark: |          | :thought_balloon: |
 | [`@typescript-eslint/unified-signatures`](./docs/rules/unified-signatures.md)                             | Warns for any two overloads that could be unified into one. (`unified-signatures` from TSLint)                                                      |                    |          |                   |
 
 <!-- end rule list -->
diff --git a/packages/eslint-plugin/ROADMAP.md b/packages/eslint-plugin/ROADMAP.md
index 11ccb8ac22b7..c0cdcbf0b3ea 100644
--- a/packages/eslint-plugin/ROADMAP.md
+++ b/packages/eslint-plugin/ROADMAP.md
@@ -77,7 +77,7 @@
 | [`no-submodule-imports`]             | 🌓  | [`import/no-internal-modules`] (slightly different)                   |
 | [`no-switch-case-fall-through`]      | 🌟  | [`no-fallthrough`][no-fallthrough]                                    |
 | [`no-this-assignment`]               | ✅  | [`@typescript-eslint/no-this-alias`]                                  |
-| [`no-unbound-method`]                | 🛑  | N/A                                                                   |
+| [`no-unbound-method`]                | ✅  | [`@typescript-eslint/unbound-method`]                                 |
 | [`no-unnecessary-class`]             | ✅  | [`@typescript-eslint/no-extraneous-class`]                            |
 | [`no-unsafe-any`]                    | 🛑  | N/A                                                                   |
 | [`no-unsafe-finally`]                | 🌟  | [`no-unsafe-finally`][no-unsafe-finally]                              |
@@ -586,6 +586,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint-
 [`@typescript-eslint/no-namespace`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-namespace.md
 [`@typescript-eslint/no-non-null-assertion`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-non-null-assertion.md
 [`@typescript-eslint/no-triple-slash-reference`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-triple-slash-reference.md
+[`@typescript-eslint/unbound-method`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/unbound-method.md
 [`@typescript-eslint/no-unnecessary-type-assertion`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-unnecessary-type-assertion.md
 [`@typescript-eslint/no-var-requires`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-var-requires.md
 [`@typescript-eslint/type-annotation-spacing`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/type-annotation-spacing.md
diff --git a/packages/eslint-plugin/docs/rules/unbound-method.md b/packages/eslint-plugin/docs/rules/unbound-method.md
new file mode 100644
index 000000000000..d0268dadeec3
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/unbound-method.md
@@ -0,0 +1,92 @@
+# Enforces unbound methods are called with their expected scope (unbound-method)
+
+Warns when a method is used outside of a method call.
+
+Class functions don't preserve the class scope when passed as standalone variables.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule
+
+```ts
+class MyClass {
+  public log(): void {
+    console.log(this);
+  }
+}
+
+const instance = new MyClass();
+
+// This logs the global scope (`window`/`global`), not the class instance
+const myLog = instance.log;
+myLog();
+
+// This log might later be called with an incorrect scope
+const { log } = instance;
+```
+
+Examples of **correct** code for this rule
+
+```ts
+class MyClass {
+  public logUnbound(): void {
+    console.log(this);
+  }
+
+  public logBound = () => console.log(this);
+}
+
+const instance = new MyClass();
+
+// logBound will always be bound with the correct scope
+const { logBound } = instance;
+logBound();
+
+// .bind and lambdas will also add a correct scope
+const dotBindLog = instance.log.bind(instance);
+const innerLog = () => instance.log();
+```
+
+## Options
+
+The rule accepts an options object with the following property:
+
+- `ignoreStatic` to not check whether `static` methods are correctly bound
+
+### `ignoreStatic`
+
+Examples of **correct** code for this rule with `{ ignoreStatic: true }`:
+
+```ts
+class OtherClass {
+  static log() {
+    console.log(OtherClass);
+  }
+}
+
+// With `ignoreStatic`, statics are assumed to not rely on a particular scope
+const { log } = OtherClass;
+
+log();
+```
+
+### Example
+
+```json
+{
+  "@typescript-eslint/unbound-method": [
+    "error",
+    {
+      "ignoreStatic": true
+    }
+  ]
+}
+```
+
+## When Not To Use It
+
+If your code intentionally waits to bind methods after use, such as by passing a `scope: this` along with the method, you can disable this rule.
+
+## Related To
+
+- TSLint: [no-unbound-method](https://palantir.github.io/tslint/rules/no-unbound-method/)
diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
new file mode 100644
index 000000000000..621e95ec7c53
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -0,0 +1,123 @@
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import * as tsutils from 'tsutils';
+import * as ts from 'typescript';
+
+import * as util from '../util';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+interface Config {
+  ignoreStatic: boolean;
+}
+
+type Options = [Config];
+
+type MessageIds = 'unbound';
+
+export default util.createRule<Options, MessageIds>({
+  name: 'unbound-method',
+  meta: {
+    docs: {
+      category: 'Best Practices',
+      description:
+        'Enforces unbound methods are called with their expected scope.',
+      tslintName: 'no-unbound-method',
+      recommended: 'error',
+    },
+    messages: {
+      unbound:
+        'Avoid referencing unbound methods which may cause unintentional scoping of `this`.',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          ignoreStatic: {
+            type: 'boolean',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    type: 'problem',
+  },
+  defaultOptions: [
+    {
+      ignoreStatic: false,
+    },
+  ],
+  create(context, [{ ignoreStatic }]) {
+    const parserServices = util.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      [AST_NODE_TYPES.MemberExpression](node: TSESTree.MemberExpression) {
+        if (isSafeUse(node)) {
+          return;
+        }
+
+        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+        const symbol = checker.getSymbolAtLocation(originalNode);
+
+        if (symbol && isDangerousMethod(symbol, ignoreStatic)) {
+          context.report({
+            messageId: 'unbound',
+            node,
+          });
+        }
+      },
+    };
+  },
+});
+
+function isDangerousMethod(symbol: ts.Symbol, ignoreStatic: boolean) {
+  const { valueDeclaration } = symbol;
+
+  switch (valueDeclaration.kind) {
+    case ts.SyntaxKind.MethodDeclaration:
+    case ts.SyntaxKind.MethodSignature:
+      return !(
+        ignoreStatic &&
+        tsutils.hasModifier(
+          valueDeclaration.modifiers,
+          ts.SyntaxKind.StaticKeyword,
+        )
+      );
+  }
+
+  return false;
+}
+
+function isSafeUse(node: TSESTree.Node): boolean {
+  const parent = node.parent!;
+
+  switch (parent.type) {
+    case AST_NODE_TYPES.IfStatement:
+    case AST_NODE_TYPES.ForStatement:
+    case AST_NODE_TYPES.MemberExpression:
+    case AST_NODE_TYPES.UpdateExpression:
+    case AST_NODE_TYPES.WhileStatement:
+      return true;
+
+    case AST_NODE_TYPES.CallExpression:
+      return parent.callee === node;
+
+    case AST_NODE_TYPES.ConditionalExpression:
+      return parent.test === node;
+
+    case AST_NODE_TYPES.LogicalExpression:
+      return parent.operator !== '||';
+
+    case AST_NODE_TYPES.TaggedTemplateExpression:
+      return parent.tag === node;
+
+    case AST_NODE_TYPES.TSNonNullExpression:
+    case AST_NODE_TYPES.TSAsExpression:
+    case AST_NODE_TYPES.TSTypeAssertion:
+      return isSafeUse(parent);
+  }
+
+  return false;
+}
diff --git a/packages/eslint-plugin/tests/rules/unbound-method.test.ts b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
new file mode 100644
index 000000000000..8b4ed003fd4c
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
@@ -0,0 +1,273 @@
+import path from 'path';
+import rule from '../../src/rules/unbound-method';
+import { RuleTester } from '../RuleTester';
+
+const rootPath = path.join(process.cwd(), 'tests/fixtures/');
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    tsconfigRootDir: rootPath,
+    project: './tsconfig.json',
+  },
+});
+
+ruleTester.run('unbound-method', rule, {
+  valid: [
+    `
+class ContainsMethods {
+  bound?: () => void;
+  unbound?(): void;
+
+  static boundStatic?: () => void;
+  static unboundStatic?(): void;
+}
+
+let instance = new ContainsMethods();
+
+instance.bound();
+instance.unbound();
+
+ContainsMethods.boundStatic();
+ContainsMethods.unboundStatic();
+
+{
+    const bound = instance.bound;
+    const boundStatic = ContainsMethods;
+}
+{
+    const { bound } = instance;
+    const { boundStatic } = ContainsMethods;
+}
+
+(instance.bound)();
+(instance.unbound)();
+
+(ContainsMethods.boundStatic)();
+(ContainsMethods.unboundStatic)();
+
+instance.bound\`\`;
+instance.unbound\`\`;
+
+if (instance.bound) { }
+if (instance.unbound) { }
+
+if (ContainsMethods.boundStatic) { }
+if (ContainsMethods.unboundStatic) { }
+
+while (instance.bound) { }
+while (instance.unbound) { }
+
+while (ContainsMethods.boundStatic) { }
+while (ContainsMethods.unboundStatic) { }
+
+instance.bound as any;
+ContainsMethods.boundStatic as any;
+
+instance.bound++;
++instance.bound;
+++instance.bound;
+instance.bound--;
+-instance.bound;
+--instance.bound;
+instance.bound += 1;
+instance.bound -= 1;
+instance.bound *= 1;
+instance.bound /= 1;
+
+instance.bound || 0;
+instane.bound && 0;
+
+instance.bound ? 1 : 0;
+instance.unbound ? 1 : 0;
+
+ContainsMethods.boundStatic++;
++ContainsMethods.boundStatic;
+++ContainsMethods.boundStatic;
+ContainsMethods.boundStatic--;
+-ContainsMethods.boundStatic;
+--ContainsMethods.boundStatic;
+ContainsMethods.boundStatic += 1;
+ContainsMethods.boundStatic -= 1;
+ContainsMethods.boundStatic *= 1;
+ContainsMethods.boundStatic /= 1;
+
+ContainsMethods.boundStatic || 0;
+instane.boundStatic && 0;
+
+ContainsMethods.boundStatic ? 1 : 0;
+ContainsMethods.unboundStatic ? 1 : 0;
+`,
+  ],
+  invalid: [
+    {
+      code: `
+class ContainsMethods {
+  bound?: () => void;
+  unbound?(): void;
+  static boundStatic?: () => void;
+  static unboundStatic?(): void;
+}
+
+const instance = new ContainsMethods();
+
+{
+  const unbound = instance.unbound;
+  const unboundStatic = ContainsMethods.unboundStatic;
+}
+{
+  const { unbound } = instance.unbound;
+  const { unboundStatic } = ContainsMethods.unboundStatic;
+}
+
+<any>instance.unbound;
+instance.unbound as any;
+
+<any>ContainsMethods.unboundStatic;
+ContainsMethods.unboundStatic as any;
+
+instance.unbound++;
++instance.unbound;
+++instance.unbound;
+instance.unbound--;
+-instance.unbound;
+--instance.unbound;
+instance.unbound += 1;
+instance.unbound -= 1;
+instance.unbound *= 1;
+instance.unbound /= 1;
+
+instance.unbound || 0;
+instance.unbound && 0;
+
+ContainsMethods.unboundStatic++;
++ContainsMethods.unboundStatic;
+++ContainsMethods.unboundStatic;
+ContainsMethods.unboundStatic--;
+-ContainsMethods.unboundStatic;
+--ContainsMethods.unboundStatic;
+ContainsMethods.unboundStatic += 1;
+ContainsMethods.unboundStatic -= 1;
+ContainsMethods.unboundStatic *= 1;
+ContainsMethods.unboundStatic /= 1;
+
+ContainsMethods.unboundStatic || 0;
+ContainsMethods.unboundStatic && 0;
+`,
+      errors: [
+        {
+          line: 12,
+          messageId: 'unbound',
+        },
+        {
+          line: 13,
+          messageId: 'unbound',
+        },
+        {
+          line: 16,
+          messageId: 'unbound',
+        },
+        {
+          line: 17,
+          messageId: 'unbound',
+        },
+        {
+          line: 20,
+          messageId: 'unbound',
+        },
+        {
+          line: 21,
+          messageId: 'unbound',
+        },
+        {
+          line: 23,
+          messageId: 'unbound',
+        },
+        {
+          line: 24,
+          messageId: 'unbound',
+        },
+        {
+          line: 27,
+          messageId: 'unbound',
+        },
+        {
+          line: 30,
+          messageId: 'unbound',
+        },
+        {
+          line: 32,
+          messageId: 'unbound',
+        },
+        {
+          line: 33,
+          messageId: 'unbound',
+        },
+        {
+          line: 34,
+          messageId: 'unbound',
+        },
+        {
+          line: 35,
+          messageId: 'unbound',
+        },
+        {
+          line: 37,
+          messageId: 'unbound',
+        },
+        {
+          line: 41,
+          messageId: 'unbound',
+        },
+        {
+          line: 44,
+          messageId: 'unbound',
+        },
+        {
+          line: 46,
+          messageId: 'unbound',
+        },
+        {
+          line: 47,
+          messageId: 'unbound',
+        },
+        {
+          line: 48,
+          messageId: 'unbound',
+        },
+        {
+          line: 49,
+          messageId: 'unbound',
+        },
+        {
+          line: 51,
+          messageId: 'unbound',
+        },
+      ],
+    },
+    {
+      code: `
+class ContainsMethods {
+  unbound?(): void;
+
+  static unboundStatic?(): void;
+}
+
+new ContainsMethods().unbound;
+
+ContainsMethods.unboundStatic;
+`,
+      options: [
+        {
+          ignoreStatic: true,
+        },
+      ],
+      errors: [
+        {
+          line: 8,
+          messageId: 'unbound',
+        },
+      ],
+    },
+  ],
+});

From fab182f9ac91147e465a0ef8f11a6d700336370b Mon Sep 17 00:00:00 2001
From: C Lentfort <clentfort@users.noreply.github.com>
Date: Thu, 4 Apr 2019 15:55:57 +0100
Subject: [PATCH 02/17] docs: correct supported typescript version (#401)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0aef0f23d0b1..0a5267f1097f 100644
--- a/README.md
+++ b/README.md
@@ -44,7 +44,7 @@ The `canary` (latest master) version is:
 
 We will always endeavor to support the latest stable version of TypeScript. Sometimes, but not always, changes in TypeScript will not require breaking changes in this project, and so we are able to support more than one version of TypeScript.
 
-**The version range of TypeScript currently supported by this parser is `>=3.2.1 <3.4.0`.**
+**The version range of TypeScript currently supported by this parser is `>=3.2.1 <3.5.0`.**
 
 This is reflected in the `devDependency` requirement within the package.json file, and it is what the tests will be run against. We have an open `peerDependency` requirement in order to allow for experimentation on newer/beta versions of TypeScript.
 

From 6f77ba611354c49252bc16768e55324fb00b0ac6 Mon Sep 17 00:00:00 2001
From: Dylan Kirkby <dylan@alloy.ai>
Date: Sat, 6 Apr 2019 17:57:28 -0700
Subject: [PATCH 03/17] chore: add some tests and refactor tsconfig path
 resolution (#412)

---
 .../typescript-estree/src/tsconfig-parser.ts  | 21 ++++-----
 .../tests/lib/semanticInfo.ts                 | 47 +++++++++++++++++++
 2 files changed, 56 insertions(+), 12 deletions(-)

diff --git a/packages/typescript-estree/src/tsconfig-parser.ts b/packages/typescript-estree/src/tsconfig-parser.ts
index 135bbdfbc04e..d953b39d8ead 100644
--- a/packages/typescript-estree/src/tsconfig-parser.ts
+++ b/packages/typescript-estree/src/tsconfig-parser.ts
@@ -50,6 +50,12 @@ function diagnosticReporter(diagnostic: ts.Diagnostic): void {
 
 const noopFileWatcher = { close: () => {} };
 
+function getTsconfigPath(tsconfigPath: string, extra: Extra): string {
+  return path.isAbsolute(tsconfigPath)
+    ? tsconfigPath
+    : path.join(extra.tsconfigRootDir || process.cwd(), tsconfigPath);
+}
+
 /**
  * Calculate project environments using options provided by consumer and paths from config
  * @param code The code being linted
@@ -64,7 +70,6 @@ export function calculateProjectParserOptions(
   extra: Extra,
 ): ts.Program[] {
   const results = [];
-  const tsconfigRootDir = extra.tsconfigRootDir;
 
   // preserve reference to code and file being linted
   currentLintOperationState.code = code;
@@ -77,11 +82,8 @@ export function calculateProjectParserOptions(
     watchCallback(filePath, ts.FileWatcherEventKind.Changed);
   }
 
-  for (let tsconfigPath of extra.projects) {
-    // if absolute paths aren't provided, make relative to tsconfigRootDir
-    if (!path.isAbsolute(tsconfigPath)) {
-      tsconfigPath = path.join(tsconfigRootDir, tsconfigPath);
-    }
+  for (let rawTsconfigPath of extra.projects) {
+    const tsconfigPath = getTsconfigPath(rawTsconfigPath, extra);
 
     const existingWatch = knownWatchProgramMap.get(tsconfigPath);
 
@@ -193,12 +195,7 @@ export function createProgram(code: string, filePath: string, extra: Extra) {
     return undefined;
   }
 
-  let tsconfigPath = extra.projects[0];
-
-  // if absolute paths aren't provided, make relative to tsconfigRootDir
-  if (!path.isAbsolute(tsconfigPath)) {
-    tsconfigPath = path.join(extra.tsconfigRootDir, tsconfigPath);
-  }
+  const tsconfigPath = getTsconfigPath(extra.projects[0], extra);
 
   const commandLine = ts.getParsedCommandLineOfConfigFile(
     tsconfigPath,
diff --git a/packages/typescript-estree/tests/lib/semanticInfo.ts b/packages/typescript-estree/tests/lib/semanticInfo.ts
index ab7df7278a07..df3fed691a40 100644
--- a/packages/typescript-estree/tests/lib/semanticInfo.ts
+++ b/packages/typescript-estree/tests/lib/semanticInfo.ts
@@ -48,6 +48,21 @@ describe('semanticInfo', () => {
     );
   });
 
+  it(`should cache the created ts.program`, () => {
+    const filename = testFiles[0];
+    const code = readFileSync(filename, 'utf8');
+    const options = createOptions(filename);
+    const optionsProjectString = {
+      ...options,
+      project: './tsconfig.json',
+    };
+    expect(
+      parseAndGenerateServices(code, optionsProjectString).services.program,
+    ).toBe(
+      parseAndGenerateServices(code, optionsProjectString).services.program,
+    );
+  });
+
   it(`should handle "project": "./tsconfig.json" and "project": ["./tsconfig.json"] the same`, () => {
     const filename = testFiles[0];
     const code = readFileSync(filename, 'utf8');
@@ -65,6 +80,38 @@ describe('semanticInfo', () => {
     );
   });
 
+  it(`should resolve absolute and relative tsconfig paths the same`, () => {
+    const filename = testFiles[0];
+    const code = readFileSync(filename, 'utf8');
+    const options = createOptions(filename);
+    const optionsAbsolutePath = {
+      ...options,
+      project: `${__dirname}/../fixtures/semanticInfo/tsconfig.json`,
+    };
+    const optionsRelativePath = {
+      ...options,
+      project: `./tsconfig.json`,
+    };
+    const absolutePathResult = parseAndGenerateServices(
+      code,
+      optionsAbsolutePath,
+    );
+    const relativePathResult = parseAndGenerateServices(
+      code,
+      optionsRelativePath,
+    );
+    if (absolutePathResult.services.program === undefined) {
+      throw new Error('Unable to create ts.program for absolute tsconfig');
+    } else if (relativePathResult.services.program === undefined) {
+      throw new Error('Unable to create ts.program for relative tsconfig');
+    }
+    expect(
+      absolutePathResult.services.program.getResolvedProjectReferences(),
+    ).toEqual(
+      relativePathResult.services.program.getResolvedProjectReferences(),
+    );
+  });
+
   // case-specific tests
   it('isolated-file tests', () => {
     const fileName = resolve(FIXTURES_DIR, 'isolated-file.src.ts');

From 2521b857ae9262a65d736be2f2238e903cc1d862 Mon Sep 17 00:00:00 2001
From: Linda_pp <rhysd@users.noreply.github.com>
Date: Sun, 7 Apr 2019 16:59:15 +0900
Subject: [PATCH 04/17] fix(eslint-plugin): no-object-literal-type-assertion:
 fix `as const` is reported (#390)

---
 .../src/rules/no-object-literal-type-assertion.ts           | 6 ++++++
 .../tests/rules/no-object-literal-type-assertion.test.ts    | 2 ++
 2 files changed, 8 insertions(+)

diff --git a/packages/eslint-plugin/src/rules/no-object-literal-type-assertion.ts b/packages/eslint-plugin/src/rules/no-object-literal-type-assertion.ts
index 55c91ac6e512..d83620133217 100644
--- a/packages/eslint-plugin/src/rules/no-object-literal-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-object-literal-type-assertion.ts
@@ -50,6 +50,12 @@ export default util.createRule<Options, MessageIds>({
         case AST_NODE_TYPES.TSAnyKeyword:
         case AST_NODE_TYPES.TSUnknownKeyword:
           return false;
+        case AST_NODE_TYPES.TSTypeReference:
+          // Ignore `as const` and `<const>` (#166)
+          return (
+            node.typeName.type === AST_NODE_TYPES.Identifier &&
+            node.typeName.name !== 'const'
+          );
         default:
           return true;
       }
diff --git a/packages/eslint-plugin/tests/rules/no-object-literal-type-assertion.test.ts b/packages/eslint-plugin/tests/rules/no-object-literal-type-assertion.test.ts
index e25e96de6940..336df4c29a1b 100644
--- a/packages/eslint-plugin/tests/rules/no-object-literal-type-assertion.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-object-literal-type-assertion.test.ts
@@ -26,6 +26,8 @@ ruleTester.run('no-object-literal-type-assertion', rule, {
     // Allow cast to 'unknown'
     `const foo = {} as unknown;`,
     `const foo = <unknown> {};`,
+    `const foo = {} as const;`,
+    `const foo = <const> {};`,
     {
       code: `print({ bar: 5 } as Foo)`,
       options: [

From 4b3d82022a45eeb52a94446454e5809fbb5812eb Mon Sep 17 00:00:00 2001
From: Gavin Barron <gavin.barron@gmail.com>
Date: Sun, 7 Apr 2019 01:07:22 -0700
Subject: [PATCH 05/17] feat(eslint-plugin): [member-accessibility] add more
 options (#322)

---
 .../rules/explicit-member-accessibility.md    | 235 ++++++++++++-
 .../rules/explicit-member-accessibility.ts    | 199 +++++++++--
 .../explicit-member-accessibility.test.ts     | 322 ++++++++++++++++++
 3 files changed, 719 insertions(+), 37 deletions(-)

diff --git a/packages/eslint-plugin/docs/rules/explicit-member-accessibility.md b/packages/eslint-plugin/docs/rules/explicit-member-accessibility.md
index ac3e8b1d7fcc..a672b766c6c9 100644
--- a/packages/eslint-plugin/docs/rules/explicit-member-accessibility.md
+++ b/packages/eslint-plugin/docs/rules/explicit-member-accessibility.md
@@ -10,28 +10,247 @@ be easier to use.
 This rule aims to make code more readable and explicit about who can use
 which properties.
 
-The following patterns are considered warnings:
+## Options
+
+```ts
+type AccessibilityLevel =
+  | 'explicit' // require an accessor (including public)
+  | 'no-public' // don't require public
+  | 'off'; // don't check
+
+interface Config {
+  accessibility?: AccessibilityLevel;
+  overrides?: {
+    accessors?: AccessibilityLevel;
+    constructors?: AccessibilityLevel;
+    methods?: AccessibilityLevel;
+    properties?: AccessibilityLevel;
+    parameterProperties?: AccessibilityLevel;
+  };
+}
+```
+
+Default config:
+
+```JSON
+{ "accessibility": "explicit" }
+```
+
+This rule in it's default state requires no configuration and will enforce that every class member has an accessibility modifier. If you would like to allow for some implicit public members then you have the following options:
+A possible configuration could be:
+
+```ts
+{
+  accessibility: 'explicit',
+  overrides {
+    accessors: 'explicit',
+    constructors: 'no-public',
+    methods: 'explicit',
+    properties: 'off',
+    parameterProperties: 'explicit'
+  }
+}
+```
+
+The following patterns are considered incorrect code if no options are provided:
+
+```ts
+class Animal {
+  constructor(name) {
+    // No accessibility modifier
+    this.animalName = name;
+  }
+  animalName: string; // No accessibility modifier
+  get name(): string {
+    // No accessibility modifier
+    return this.animalName;
+  }
+  set name(value: string) {
+    // No accessibility modifier
+    this.animalName = value;
+  }
+  walk() {
+    // method
+  }
+}
+```
+
+The following patterns are considered correct with the default options `{ accessibility: 'explicit' }`:
+
+```ts
+class Animal {
+  public constructor(public breed, animalName) {
+    // Parameter property and constructor
+    this.animalName = name;
+  }
+  private animalName: string; // Property
+  get name(): string {
+    // get accessor
+    return this.animalName;
+  }
+  set name(value: string) {
+    // set accessor
+    this.animalName = value;
+  }
+  public walk() {
+    // method
+  }
+}
+```
+
+The following patterns are considered incorrect with the accessibility set to **no-public** `[{ accessibility: 'no-public' }]`:
+
+```ts
+class Animal {
+  public constructor(public breed, animalName) {
+    // Parameter property and constructor
+    this.animalName = name;
+  }
+  public animalName: string; // Property
+  public get name(): string {
+    // get accessor
+    return this.animalName;
+  }
+  public set name(value: string) {
+    // set accessor
+    this.animalName = value;
+  }
+  public walk() {
+    // method
+  }
+}
+```
+
+The following patterns are considered correct with the accessibility set to **no-public** `[{ accessibility: 'no-public' }]`:
+
+```ts
+class Animal {
+  constructor(protected breed, animalName) {
+    // Parameter property and constructor
+    this.name = name;
+  }
+  private animalName: string; // Property
+  get name(): string {
+    // get accessor
+    return this.animalName;
+  }
+  private set name(value: string) {
+    // set accessor
+    this.animalName = value;
+  }
+  protected walk() {
+    // method
+  }
+}
+```
+
+### Overrides
+
+There are three ways in which an override can be used.
+
+- To disallow the use of public on a given member.
+- To enforce explicit member accessibility when the root has allowed implicit public accessibility
+- To disable any checks on given member type
+
+#### Disallow the use of public on a given member
+
+e.g. `[ { overrides: { constructor: 'no-public' } } ]`
+
+The following patterns are considered incorrect with the example override
+
+```ts
+class Animal {
+  public constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+}
+```
+
+The following patterns are considered correct with the example override
+
+```ts
+class Animal {
+  constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+}
+```
+
+#### Require explicit accessibility for a given member
+
+e.g. `[ { accessibility: 'no-public', overrides: { properties: 'explicit' } } ]`
+
+The following patterns are considered incorrect with the example override
+
+```ts
+class Animal {
+  constructor(protected animalName) {}
+  get name() {
+    return this.animalName;
+  }
+  protected set name(value: string) {
+    this.animalName = value;
+  }
+  legs: number;
+  private hasFleas: boolean;
+}
+```
+
+The following patterns are considered correct with the example override
+
+```ts
+class Animal {
+  constructor(protected animalName) {}
+  get name() {
+    return this.animalName;
+  }
+  protected set name(value: string) {
+    this.animalName = value;
+  }
+  public legs: number;
+  private hasFleas: boolean;
+}
+```
+
+#### Disable any checks on given member type
+
+e.g. `[{ overrides: { accessors : 'off' } } ]`
+
+As no checks on the overridden member type are performed all permutations of visibility are permitted for that member type
+
+The follow pattern is considered incorrect for the given configuration
 
 ```ts
 class Animal {
-  name: string; // No accessibility modifier
-  getName(): string {} // No accessibility modifier
+  constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+  get legs() {
+    return this.legCount;
+  }
 }
 ```
 
-The following patterns are not warnings:
+The following patterns are considered correct with the example override
 
 ```ts
 class Animal {
-  private name: string; // explicit accessibility modifier
-  public getName(): string {} // explicit accessibility modifier
+  public constructor(protected animalName) {}
+  public get name() {
+    return this.animalName;
+  }
+  get legs() {
+    return this.legCount;
+  }
 }
 ```
 
 ## When Not To Use It
 
-If you think defaulting to public is a good default, then you will not need
-this rule.
+If you think defaulting to public is a good default, then you should consider using the `no-public` setting. If you want to mix implicit and explicit public members then disable this rule.
 
 ## Further Reading
 
diff --git a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
index 66029faa5018..be79d684a690 100644
--- a/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
+++ b/packages/eslint-plugin/src/rules/explicit-member-accessibility.ts
@@ -1,7 +1,29 @@
-import { TSESTree } from '@typescript-eslint/typescript-estree';
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
-export default util.createRule({
+type AccessibilityLevel =
+  | 'explicit' // require an accessor (including public)
+  | 'no-public' // don't require public
+  | 'off'; // don't check
+
+interface Config {
+  accessibility?: AccessibilityLevel;
+  overrides?: {
+    accessors?: AccessibilityLevel;
+    constructors?: AccessibilityLevel;
+    methods?: AccessibilityLevel;
+    properties?: AccessibilityLevel;
+    parameterProperties?: AccessibilityLevel;
+  };
+}
+
+type Options = [Config];
+
+type MessageIds = 'unwantedPublicAccessibility' | 'missingAccessibility';
+
+const accessibilityLevel = { enum: ['explicit', 'no-public', 'off'] };
+
+export default util.createRule<Options, MessageIds>({
   name: 'explicit-member-accessibility',
   meta: {
     type: 'problem',
@@ -15,12 +37,60 @@ export default util.createRule({
     messages: {
       missingAccessibility:
         'Missing accessibility modifier on {{type}} {{name}}.',
+      unwantedPublicAccessibility:
+        'Public accessibility modifier on {{type}} {{name}}.',
     },
-    schema: [],
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          accessibility: accessibilityLevel,
+          overrides: {
+            type: 'object',
+            properties: {
+              accessors: accessibilityLevel,
+              constructors: accessibilityLevel,
+              methods: accessibilityLevel,
+              properties: accessibilityLevel,
+              parameterProperties: accessibilityLevel,
+            },
+            additionalProperties: false,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
   },
-  defaultOptions: [],
-  create(context) {
+  defaultOptions: [{ accessibility: 'explicit' }],
+  create(context, [option]) {
     const sourceCode = context.getSourceCode();
+    const baseCheck: AccessibilityLevel = option.accessibility || 'explicit';
+    const overrides = option.overrides || {};
+    const ctorCheck = overrides.constructors || baseCheck;
+    const accessorCheck = overrides.accessors || baseCheck;
+    const methodCheck = overrides.methods || baseCheck;
+    const propCheck = overrides.properties || baseCheck;
+    const paramPropCheck = overrides.parameterProperties || baseCheck;
+
+    /**
+     * Generates the report for rule violations
+     */
+    function reportIssue(
+      messageId: MessageIds,
+      nodeType: string,
+      node: TSESTree.Node,
+      nodeName: string,
+    ) {
+      context.report({
+        node: node,
+        messageId: messageId,
+        data: {
+          type: nodeType,
+          name: nodeName,
+        },
+      });
+    }
+
     /**
      * Checks if a method declaration has an accessibility modifier.
      * @param methodDefinition The node representing a MethodDefinition.
@@ -28,18 +98,49 @@ export default util.createRule({
     function checkMethodAccessibilityModifier(
       methodDefinition: TSESTree.MethodDefinition,
     ): void {
-      if (
-        !methodDefinition.accessibility &&
-        util.isTypeScriptFile(context.getFilename())
-      ) {
-        context.report({
-          node: methodDefinition,
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'method definition',
-            name: util.getNameFromClassMember(methodDefinition, sourceCode),
-          },
-        });
+      let nodeType = 'method definition';
+      let check = baseCheck;
+      switch (methodDefinition.kind) {
+        case 'method':
+          check = methodCheck;
+          break;
+        case 'constructor':
+          check = ctorCheck;
+          break;
+        case 'get':
+        case 'set':
+          check = accessorCheck;
+          nodeType = `${methodDefinition.kind} property accessor`;
+          break;
+      }
+      if (check === 'off') {
+        return;
+      }
+
+      if (util.isTypeScriptFile(context.getFilename())) {
+        // const methodName = util.getNameFromPropertyName(methodDefinition.key);
+        const methodName = util.getNameFromClassMember(
+          methodDefinition,
+          sourceCode,
+        );
+        if (
+          check === 'no-public' &&
+          methodDefinition.accessibility === 'public'
+        ) {
+          reportIssue(
+            'unwantedPublicAccessibility',
+            nodeType,
+            methodDefinition,
+            methodName,
+          );
+        } else if (check === 'explicit' && !methodDefinition.accessibility) {
+          reportIssue(
+            'missingAccessibility',
+            nodeType,
+            methodDefinition,
+            methodName,
+          );
+        }
       }
     }
 
@@ -50,22 +151,62 @@ export default util.createRule({
     function checkPropertyAccessibilityModifier(
       classProperty: TSESTree.ClassProperty,
     ): void {
-      if (
-        !classProperty.accessibility &&
-        util.isTypeScriptFile(context.getFilename())
-      ) {
-        context.report({
-          node: classProperty,
-          messageId: 'missingAccessibility',
-          data: {
-            type: 'class property',
-            name: util.getNameFromPropertyName(classProperty.key),
-          },
-        });
+      const nodeType = 'class property';
+
+      if (util.isTypeScriptFile(context.getFilename())) {
+        const propertyName = util.getNameFromPropertyName(classProperty.key);
+        if (
+          propCheck === 'no-public' &&
+          classProperty.accessibility === 'public'
+        ) {
+          reportIssue(
+            'unwantedPublicAccessibility',
+            nodeType,
+            classProperty,
+            propertyName,
+          );
+        } else if (propCheck === 'explicit' && !classProperty.accessibility) {
+          reportIssue(
+            'missingAccessibility',
+            nodeType,
+            classProperty,
+            propertyName,
+          );
+        }
+      }
+    }
+
+    /**
+     * Checks that the parameter property has the desired accessibility modifiers set.
+     * @param {TSESTree.TSParameterProperty} node The node representing a Parameter Property
+     */
+    function checkParameterPropertyAccessibilityModifier(
+      node: TSESTree.TSParameterProperty,
+    ) {
+      const nodeType = 'parameter property';
+      if (util.isTypeScriptFile(context.getFilename())) {
+        // HAS to be an identifier or assignment or TSC will throw
+        if (
+          node.parameter.type !== AST_NODE_TYPES.Identifier &&
+          node.parameter.type !== AST_NODE_TYPES.AssignmentPattern
+        ) {
+          return;
+        }
+
+        const nodeName =
+          node.parameter.type === AST_NODE_TYPES.Identifier
+            ? node.parameter.name
+            : // has to be an Identifier or TSC will throw an error
+              (node.parameter.left as TSESTree.Identifier).name;
+
+        if (paramPropCheck === 'no-public' && node.accessibility === 'public') {
+          reportIssue('unwantedPublicAccessibility', nodeType, node, nodeName);
+        }
       }
     }
 
     return {
+      TSParameterProperty: checkParameterPropertyAccessibilityModifier,
       ClassProperty: checkPropertyAccessibilityModifier,
       MethodDefinition: checkMethodAccessibilityModifier,
     };
diff --git a/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts b/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
index e630450689ce..51a94a19de20 100644
--- a/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
+++ b/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
@@ -39,6 +39,129 @@ class Test {
 }
             `,
     },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  protected name: string
+  protected foo?: string
+  public getX () {
+    return this.x
+  }
+}
+            `,
+      options: [{ accessibility: 'explicit' }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  protected name: string
+  protected foo?: string
+  getX () {
+    return this.x
+  }
+}
+            `,
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  name: string
+  foo?: string
+  getX () {
+    return this.x
+  }
+  get fooName(): string {
+    return this.foo + ' ' + this.name
+  }
+}
+            `,
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  private x: number;
+  constructor (x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  private set internalValue(value: number) {
+    this.x = value;
+  }
+  public square (): number {
+    return this.x * this.x;
+  }
+}
+      `,
+      options: [{ overrides: { constructors: 'off', accessors: 'off' } }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  private x: number;
+  public constructor (x: number) {
+    this.x = x;
+  }
+  public get internalValue() {
+    return this.x;
+  }
+  public set internalValue(value: number) {
+    this.x = value;
+  }
+  public square (): number {
+    return this.x * this.x;
+  }
+  half (): number {
+    return this.x / 2;
+  }
+}
+      `,
+      options: [{ overrides: { methods: 'off' } }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  constructor(private x: number){}
+}
+      `,
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  constructor(public x: number){}
+}
+      `,
+      options: [
+        {
+          accessibility: 'no-public',
+          overrides: { parameterProperties: 'off' },
+        },
+      ],
+    },
+    {
+      filename: 'test.js',
+      code: `
+class Test {
+  constructor(public x: number){}
+}
+      `,
+      options: [
+        {
+          accessibility: 'no-public',
+        },
+      ],
+    },
   ],
   invalid: [
     {
@@ -116,5 +239,204 @@ class Test {
         },
       ],
     },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  protected name: string
+  protected foo?: string
+  public getX () {
+    return this.x
+  }
+}
+            `,
+      options: [{ accessibility: 'no-public' }],
+      errors: [
+        {
+          messageId: 'unwantedPublicAccessibility',
+          data: {
+            type: 'method definition',
+            name: 'getX',
+          },
+          line: 5,
+          column: 3,
+        },
+      ],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  protected name: string
+  public foo?: string
+  getX () {
+    return this.x
+  }
+}
+            `,
+      options: [{ accessibility: 'no-public' }],
+      errors: [
+        {
+          messageId: 'unwantedPublicAccessibility',
+          data: {
+            type: 'class property',
+            name: 'foo',
+          },
+          line: 4,
+          column: 3,
+        },
+      ],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  public x: number
+  public getX () {
+    return this.x
+  }
+}
+            `,
+      errors: [
+        {
+          messageId: 'unwantedPublicAccessibility',
+          line: 3,
+          column: 3,
+        },
+        {
+          messageId: 'unwantedPublicAccessibility',
+          line: 4,
+          column: 3,
+        },
+      ],
+      options: [{ accessibility: 'no-public' }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  private x: number;
+  constructor (x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+      errors: [
+        {
+          messageId: 'missingAccessibility',
+          line: 7,
+          column: 3,
+        },
+        {
+          messageId: 'missingAccessibility',
+          line: 10,
+          column: 3,
+        },
+      ],
+      options: [{ overrides: { constructors: 'no-public' } }],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  private x: number;
+  constructor (x: number) {
+    this.x = x;
+  }
+  get internalValue() {
+    return this.x;
+  }
+  set internalValue(value: number) {
+    this.x = value;
+  }
+}
+      `,
+      errors: [
+        {
+          messageId: 'missingAccessibility',
+          line: 4,
+          column: 3,
+        },
+        {
+          messageId: 'missingAccessibility',
+          line: 7,
+          column: 3,
+        },
+        {
+          messageId: 'missingAccessibility',
+          line: 10,
+          column: 3,
+        },
+      ],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  constructor(public x: number){}
+}
+      `,
+      errors: [
+        {
+          messageId: 'unwantedPublicAccessibility',
+          line: 3,
+          column: 15,
+        },
+      ],
+      options: [
+        {
+          accessibility: 'no-public',
+        },
+      ],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  constructor(public x: number){}
+  public foo(): string {
+    return 'foo';
+  }
+}
+      `,
+      errors: [
+        {
+          messageId: 'missingAccessibility',
+          line: 3,
+          column: 3,
+        },
+        {
+          messageId: 'unwantedPublicAccessibility',
+          line: 3,
+          column: 15,
+        },
+      ],
+      options: [
+        {
+          overrides: { parameterProperties: 'no-public' },
+        },
+      ],
+    },
+    {
+      filename: 'test.ts',
+      code: `
+class Test {
+  constructor(public x: number){}
+}
+      `,
+      errors: [
+        {
+          messageId: 'missingAccessibility',
+          line: 3,
+          column: 3,
+        },
+      ],
+    },
   ],
 });

From d476f15a9d3e2642419a8facc6231b952de9a934 Mon Sep 17 00:00:00 2001
From: Scott O'Hara <scott@oharagroup.net>
Date: Sun, 7 Apr 2019 19:35:37 +1000
Subject: [PATCH 06/17] fix(eslint-plugin): indent: fix false positive on type
 parameters (#385)

---
 packages/eslint-plugin/src/rules/indent.ts    |  1 +
 .../eslint-plugin/tests/rules/indent.test.ts  | 24 +++++++++++++++++++
 2 files changed, 25 insertions(+)

diff --git a/packages/eslint-plugin/src/rules/indent.ts b/packages/eslint-plugin/src/rules/indent.ts
index a3c6f5971d5e..85187a7046ba 100644
--- a/packages/eslint-plugin/src/rules/indent.ts
+++ b/packages/eslint-plugin/src/rules/indent.ts
@@ -74,6 +74,7 @@ const KNOWN_NODES = new Set([
   AST_NODE_TYPES.TSTypeOperator,
   AST_NODE_TYPES.TSTypeParameter,
   AST_NODE_TYPES.TSTypeParameterDeclaration,
+  AST_NODE_TYPES.TSTypeParameterInstantiation,
   AST_NODE_TYPES.TSTypeReference,
   AST_NODE_TYPES.TSUnionType,
 ]);
diff --git a/packages/eslint-plugin/tests/rules/indent.test.ts b/packages/eslint-plugin/tests/rules/indent.test.ts
index d845a8711721..7fb18428d9fc 100644
--- a/packages/eslint-plugin/tests/rules/indent.test.ts
+++ b/packages/eslint-plugin/tests/rules/indent.test.ts
@@ -742,6 +742,30 @@ const foo : Foo = {
             `,
       options: [4, { VariableDeclarator: { const: 3 } }],
     },
+    {
+      code: `
+const name: string = '  Typescript  '
+        .toUpperCase()
+        .trim(),
+
+      greeting: string = (" Hello " + name)
+        .toUpperCase()
+        .trim();
+            `,
+      options: [2, { VariableDeclarator: { const: 3 } }],
+    },
+    {
+      code: `
+const div: JQuery<HTMLElement> = $('<div>')
+        .addClass('some-class')
+        .appendTo($('body')),
+
+      button: JQuery<HTMLElement> = $('<button>')
+        .text('Cancel')
+        .appendTo(div);
+            `,
+      options: [2, { VariableDeclarator: { const: 3 } }],
+    },
   ],
   invalid: [
     ...individualNodeTests.invalid,

From 3e26ab684ae5642e9c50940bedd155e32e189900 Mon Sep 17 00:00:00 2001
From: Evan Shaw <edsrzf@gmail.com>
Date: Mon, 8 Apr 2019 00:45:51 +1200
Subject: [PATCH 07/17] feat(eslint-plugin): add prefer-for-of rule (#338)

---
 packages/eslint-plugin/README.md              |   1 +
 packages/eslint-plugin/ROADMAP.md             |   3 +-
 .../eslint-plugin/docs/rules/prefer-for-of.md |  41 +++
 .../eslint-plugin/src/rules/prefer-for-of.ts  | 217 ++++++++++++
 .../tests/rules/prefer-for-of.test.ts         | 317 ++++++++++++++++++
 5 files changed, 578 insertions(+), 1 deletion(-)
 create mode 100644 packages/eslint-plugin/docs/rules/prefer-for-of.md
 create mode 100644 packages/eslint-plugin/src/rules/prefer-for-of.ts
 create mode 100644 packages/eslint-plugin/tests/rules/prefer-for-of.test.ts

diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
index 8057f15843d4..22754a977c4d 100644
--- a/packages/eslint-plugin/README.md
+++ b/packages/eslint-plugin/README.md
@@ -146,6 +146,7 @@ Then you should add `airbnb` (or `airbnb-base`) to your `extends` section of `.e
 | [`@typescript-eslint/no-use-before-define`](./docs/rules/no-use-before-define.md)                         | Disallow the use of variables before they are defined                                                                                               | :heavy_check_mark: |          |                   |
 | [`@typescript-eslint/no-useless-constructor`](./docs/rules/no-useless-constructor.md)                     | Disallow unnecessary constructors                                                                                                                   |                    |          |                   |
 | [`@typescript-eslint/no-var-requires`](./docs/rules/no-var-requires.md)                                   | Disallows the use of require statements except in import statements (`no-var-requires` from TSLint)                                                 | :heavy_check_mark: |          |                   |
+| [`@typescript-eslint/prefer-for-of`](./docs/rules/prefer-for-of.md)                                       | Prefer a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated.                                     |                    |          |                   |
 | [`@typescript-eslint/prefer-function-type`](./docs/rules/prefer-function-type.md)                         | Use function types instead of interfaces with call signatures (`callable-types` from TSLint)                                                        |                    | :wrench: |                   |
 | [`@typescript-eslint/prefer-interface`](./docs/rules/prefer-interface.md)                                 | Prefer an interface declaration over a type literal (type T = { ... }) (`interface-over-type-literal` from TSLint)                                  | :heavy_check_mark: | :wrench: |                   |
 | [`@typescript-eslint/prefer-namespace-keyword`](./docs/rules/prefer-namespace-keyword.md)                 | Require the use of the `namespace` keyword instead of the `module` keyword to declare custom TypeScript modules. (`no-internal-module` from TSLint) | :heavy_check_mark: | :wrench: |                   |
diff --git a/packages/eslint-plugin/ROADMAP.md b/packages/eslint-plugin/ROADMAP.md
index c0cdcbf0b3ea..6df8aa7fe31c 100644
--- a/packages/eslint-plugin/ROADMAP.md
+++ b/packages/eslint-plugin/ROADMAP.md
@@ -30,7 +30,7 @@
 | [`no-unnecessary-type-assertion`] | ✅  | [`@typescript-eslint/no-unnecessary-type-assertion`] |
 | [`no-var-requires`]               | ✅  | [`@typescript-eslint/no-var-requires`]               |
 | [`only-arrow-functions`]          | 🔌  | [`prefer-arrow/prefer-arrow-functions`]              |
-| [`prefer-for-of`]                 | 🛑  | N/A                                                  |
+| [`prefer-for-of`]                 | ✅  | [`@typescript-eslint/prefer-for-of`]                 |
 | [`promise-function-async`]        | ✅  | [`@typescript-eslint/promise-function-async`]        |
 | [`typedef`]                       | 🛑  | N/A                                                  |
 | [`typedef-whitespace`]            | ✅  | [`@typescript-eslint/type-annotation-spacing`]       |
@@ -606,6 +606,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint-
 [`@typescript-eslint/no-angle-bracket-type-assertion`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-angle-bracket-type-assertion.md
 [`@typescript-eslint/no-parameter-properties`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-parameter-properties.md
 [`@typescript-eslint/member-delimiter-style`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/member-delimiter-style.md
+[`@typescript-eslint/prefer-for-of`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/prefer-for-of.md
 [`@typescript-eslint/prefer-interface`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/prefer-interface.md
 [`@typescript-eslint/no-array-constructor`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-array-constructor.md
 [`@typescript-eslint/prefer-function-type`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/prefer-function-type.md
diff --git a/packages/eslint-plugin/docs/rules/prefer-for-of.md b/packages/eslint-plugin/docs/rules/prefer-for-of.md
new file mode 100644
index 000000000000..a937709f7ebe
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/prefer-for-of.md
@@ -0,0 +1,41 @@
+# Use for-of loops instead of standard for loops over arrays (prefer-for-of)
+
+This rule recommends a for-of loop when the loop index is only used to read from an array that is being iterated.
+
+## Rule Details
+
+For cases where the index is only used to read from the array being iterated, a for-of loop is easier to read and write.
+
+Examples of **incorrect** code for this rule:
+
+```js
+for (let i = 0; i < arr.length; i++) {
+  console.log(arr[i]);
+}
+```
+
+Examples of **correct** code for this rule:
+
+```js
+for (const x of arr) {
+  console.log(x);
+}
+
+for (let i = 0; i < arr.length; i++) {
+  // i is used to write to arr, so for-of could not be used.
+  arr[i] = 0;
+}
+
+for (let i = 0; i < arr.length; i++) {
+  // i is used independent of arr, so for-of could not be used.
+  console.log(i, arr[i]);
+}
+```
+
+## When Not To Use It
+
+If you transpile for browsers that do not support for-of loops, you may wish to use traditional for loops that produce more compact code.
+
+## Related to
+
+- TSLint: ['prefer-for-of'](https://palantir.github.io/tslint/rules/prefer-for-of/)
diff --git a/packages/eslint-plugin/src/rules/prefer-for-of.ts b/packages/eslint-plugin/src/rules/prefer-for-of.ts
new file mode 100644
index 000000000000..4b542cd91092
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/prefer-for-of.ts
@@ -0,0 +1,217 @@
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/typescript-estree';
+import * as util from '../util';
+import { Scope } from 'ts-eslint';
+
+export default util.createRule({
+  name: 'prefer-for-of',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated.',
+      category: 'Stylistic Issues',
+      recommended: false,
+      tslintName: 'prefer-for-of',
+    },
+    messages: {
+      preferForOf:
+        'Expected a `for-of` loop instead of a `for` loop with this simple iteration',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    function isSingleVariableDeclaration(
+      node: TSESTree.Node | null,
+    ): node is TSESTree.VariableDeclaration {
+      return (
+        node !== null &&
+        node.type === AST_NODE_TYPES.VariableDeclaration &&
+        node.kind !== 'const' &&
+        node.declarations.length === 1
+      );
+    }
+
+    function isLiteral(node: TSESTree.Expression, value: number): boolean {
+      return node.type === AST_NODE_TYPES.Literal && node.value === value;
+    }
+
+    function isZeroInitialized(node: TSESTree.VariableDeclarator): boolean {
+      return node.init !== null && isLiteral(node.init, 0);
+    }
+
+    function isMatchingIdentifier(
+      node: TSESTree.Expression,
+      name: string,
+    ): boolean {
+      return node.type === AST_NODE_TYPES.Identifier && node.name === name;
+    }
+
+    function isLessThanLengthExpression(
+      node: TSESTree.Node | null,
+      name: string,
+    ): TSESTree.Expression | null {
+      if (
+        node !== null &&
+        node.type === AST_NODE_TYPES.BinaryExpression &&
+        node.operator === '<' &&
+        isMatchingIdentifier(node.left, name) &&
+        node.right.type === AST_NODE_TYPES.MemberExpression &&
+        isMatchingIdentifier(node.right.property, 'length')
+      ) {
+        return node.right.object;
+      }
+      return null;
+    }
+
+    function isIncrement(node: TSESTree.Node | null, name: string): boolean {
+      if (!node) {
+        return false;
+      }
+      switch (node.type) {
+        case AST_NODE_TYPES.UpdateExpression:
+          // x++ or ++x
+          return (
+            node.operator === '++' && isMatchingIdentifier(node.argument, name)
+          );
+        case AST_NODE_TYPES.AssignmentExpression:
+          if (isMatchingIdentifier(node.left, name)) {
+            if (node.operator === '+=') {
+              // x += 1
+              return isLiteral(node.right, 1);
+            } else if (node.operator === '=') {
+              // x = x + 1 or x = 1 + x
+              const expr = node.right;
+              return (
+                expr.type === AST_NODE_TYPES.BinaryExpression &&
+                expr.operator === '+' &&
+                ((isMatchingIdentifier(expr.left, name) &&
+                  isLiteral(expr.right, 1)) ||
+                  (isLiteral(expr.left, 1) &&
+                    isMatchingIdentifier(expr.right, name)))
+              );
+            }
+          }
+      }
+      return false;
+    }
+
+    function contains(outer: TSESTree.Node, inner: TSESTree.Node): boolean {
+      return (
+        outer.range[0] <= inner.range[0] && outer.range[1] >= inner.range[1]
+      );
+    }
+
+    function isAssignee(node: TSESTree.Node): boolean {
+      const parent = node.parent;
+      if (!parent) {
+        return false;
+      }
+
+      // a[i] = 1, a[i] += 1, etc.
+      if (
+        parent.type === AST_NODE_TYPES.AssignmentExpression &&
+        parent.left === node
+      ) {
+        return true;
+      }
+
+      // delete a[i]
+      if (
+        parent.type === AST_NODE_TYPES.UnaryExpression &&
+        parent.operator === 'delete' &&
+        parent.argument === node
+      ) {
+        return true;
+      }
+
+      // a[i]++, --a[i], etc.
+      if (
+        parent.type === AST_NODE_TYPES.UpdateExpression &&
+        parent.argument === node
+      ) {
+        return true;
+      }
+
+      // [a[i]] = [0]
+      if (parent.type === AST_NODE_TYPES.ArrayPattern) {
+        return true;
+      }
+
+      // [...a[i]] = [0]
+      if (parent.type === AST_NODE_TYPES.RestElement) {
+        return true;
+      }
+
+      // ({ foo: a[i] }) = { foo: 0 }
+      if (
+        parent.type === AST_NODE_TYPES.Property &&
+        parent.parent !== undefined &&
+        parent.parent.type === AST_NODE_TYPES.ObjectExpression &&
+        parent.value === node &&
+        isAssignee(parent.parent)
+      ) {
+        return true;
+      }
+
+      return false;
+    }
+
+    function isIndexOnlyUsedWithArray(
+      body: TSESTree.Statement,
+      indexVar: Scope.Variable,
+      arrayExpression: TSESTree.Expression,
+    ): boolean {
+      const sourceCode = context.getSourceCode();
+      const arrayText = sourceCode.getText(arrayExpression);
+      return indexVar.references.every(reference => {
+        const id = reference.identifier;
+        const node = id.parent;
+        return (
+          !contains(body, id) ||
+          (node !== undefined &&
+            node.type === AST_NODE_TYPES.MemberExpression &&
+            node.property === id &&
+            sourceCode.getText(node.object) === arrayText &&
+            !isAssignee(node))
+        );
+      });
+    }
+
+    return {
+      'ForStatement:exit'(node: TSESTree.ForStatement) {
+        if (!isSingleVariableDeclaration(node.init)) {
+          return;
+        }
+
+        const [declarator] = node.init.declarations;
+        if (
+          !isZeroInitialized(declarator) ||
+          declarator.id.type !== AST_NODE_TYPES.Identifier
+        ) {
+          return;
+        }
+
+        const indexName = declarator.id.name;
+        const arrayExpression = isLessThanLengthExpression(
+          node.test,
+          indexName,
+        );
+        if (!arrayExpression) {
+          return;
+        }
+
+        const [indexVar] = context.getDeclaredVariables(node.init);
+        if (
+          isIncrement(node.update, indexName) &&
+          isIndexOnlyUsedWithArray(node.body, indexVar, arrayExpression)
+        ) {
+          context.report({
+            node,
+            messageId: 'preferForOf',
+          });
+        }
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts b/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
new file mode 100644
index 000000000000..db4dcd3bbf91
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
@@ -0,0 +1,317 @@
+import rule from '../../src/rules/prefer-for-of';
+import { RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('prefer-for-of', rule, {
+  valid: [
+    `
+for (let i = 0; i < arr1.length; i++) {
+  const x = arr1[i] === arr2[i];
+}
+  `,
+    `
+for (let i = 0; i < arr.length; i++) {
+  arr[i] = 0;
+}
+  `,
+    `
+for (var c = 0; c < arr.length; c++) {
+  doMath(c);
+}
+  `,
+    `
+for (var d = 0; d < arr.length; d++) doMath(d);
+`,
+    `
+for (var e = 0; e < arr.length; e++) {
+  if(e > 5) {
+    doMath(e);
+  }
+  console.log(arr[e]);
+}
+`,
+    `
+for (var f = 0; f <= 40; f++) {
+  doMath(f);
+}
+`,
+    `
+for (var g = 0; g <= 40; g++) doMath(g);
+`,
+    `
+for(var h=0, len=arr.length; h < len; h++) {}
+`,
+    `
+for(var i=0, len=arr.length; i < len; i++) arr[i];
+`,
+    `
+var m = 0;
+for (;;) {
+  if (m > 3) break;
+  console.log(m);
+  m++;
+}
+`,
+    `
+var n = 0;
+for (; n < 9; n++) {
+  console.log(n);
+}
+`,
+    `
+var o = 0;
+for (; o < arr.length; o++) {
+  console.log(arr[o]);
+}
+`,
+    `
+for(; x < arr.length; x++) {}
+`,
+    `
+for(let x = 0;; x++) {}
+`,
+    `
+for(let x = 0; x < arr.length;) {}
+`,
+    `
+for(let x = 0; NOTX < arr.length; x++) {}
+`,
+    `
+for(let x = 0; x < arr.length; NOTX++) {}
+`,
+    `
+for(let NOTX = 0; x < arr.length; x++) {}
+`,
+    `
+for(let x = 0; x < arr.length; x--) {}
+`,
+    `
+for(let x = 0; x <= arr.length; x++) {}
+`,
+    `
+for(let x = 1; x < arr.length; x++) {}
+
+`,
+    `
+for(let x = 0; x < arr.length(); x++) {}
+`,
+    `
+for(let x = 0; x < arr.length; x+=11) {}
+`,
+    `
+for(let x = 0; x < arr.length; x=x+11) {}
+`,
+    `
+for(let x = 0; x < arr.length; x++) {
+  x++;
+}
+`,
+    `
+for(let x = 0; true; x++) {}
+`,
+    `
+for (var q in obj) {
+  if (obj.hasOwnProperty(q)) {
+    console.log(q);
+  }
+}
+`,
+    `
+for (var r of arr) {
+  console.log(r);
+}
+`,
+    `
+for (let x = 0; x < arr.length; x++) {
+  let y = arr[x + 1];
+}
+`,
+    `
+for (let i = 0; i < arr.length; i++) {
+  delete arr[i];
+}
+`,
+    `
+for (let i = 0; i < arr.length; i++) {
+  [arr[i]] = [1];
+}
+`,
+    `
+for (let i = 0; i < arr.length; i++) {
+  [...arr[i]] = [1];
+}
+`,
+    `
+for (let i = 0; i < arr.length; i++) {
+  ({ foo: arr[i] }) = { foo: 0 };
+}
+`,
+  ],
+  invalid: [
+    {
+      code: `
+for (var a = 0; a < obj.arr.length; a++) {
+  console.log(obj.arr[a]);
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (var b = 0; b < arr.length; b++) console.log(arr[b]);
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let a = 0; a < arr.length; a++) {
+  console.log(arr[a]);
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let a = 0; a < arr.length; ++a) {
+  arr[a].whatever();
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for(let x = 0; x < arr.length; x++) {}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for(let x = 0; x < arr.length; x+=1) {}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for(let x = 0; x < arr.length; x=x+1) {}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for(let x = 0; x < arr.length; x=1+x) {}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let shadow = 0; shadow < arr.length; shadow++) {
+  for (let shadow = 0; shadow < arr.length; shadow++) {
+  }
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let i = 0; i < arr.length; i++) {
+  obj[arr[i]] = 1;
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let i = 0; i < arr.length; i++) {
+  delete obj[arr[i]];
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let i = 0; i < arr.length; i++) {
+  [obj[arr[i]]] = [1];
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let i = 0; i < arr.length; i++) {
+  [...obj[arr[i]]] = [1];
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+    {
+      code: `
+for (let i = 0; i < arr.length; i++) {
+  ({ foo: obj[arr[i]] }) = { foo: 1 };
+}
+        `,
+      errors: [
+        {
+          messageId: 'preferForOf',
+        },
+      ],
+    },
+  ],
+});

From 12d47ae500f3618123e24d2717709c51ad813919 Mon Sep 17 00:00:00 2001
From: Matt Kantor <the.matt.kantor@gmail.com>
Date: Tue, 9 Apr 2019 13:07:01 -0700
Subject: [PATCH 08/17] docs(eslint-plugin): `as const` with
 no-object-literal-type-assertion (#419)

This doc change was overlooked when the feature was added in b70c283.
---
 .../docs/rules/no-object-literal-type-assertion.md              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/docs/rules/no-object-literal-type-assertion.md b/packages/eslint-plugin/docs/rules/no-object-literal-type-assertion.md
index b81ae0d87b69..044c68aa57fd 100644
--- a/packages/eslint-plugin/docs/rules/no-object-literal-type-assertion.md
+++ b/packages/eslint-plugin/docs/rules/no-object-literal-type-assertion.md
@@ -1,6 +1,6 @@
 # Forbids an object literal to appear in a type assertion expression (no-object-literal-type-assertion)
 
-Always prefer `const x: T = { ... };` to `const x = { ... } as T;`. Casting to `any` and `unknown` is still allowed.
+Always prefer `const x: T = { ... };` to `const x = { ... } as T;`. Casting to `any` and `unknown` is still allowed, and const assertions (`as const`) are still allowed.
 
 ## Rule Details
 

From 01c4daecd053e21372794a49a50925ad031d15e1 Mon Sep 17 00:00:00 2001
From: Toru Nagashima <star.ctor@gmail.com>
Date: Thu, 11 Apr 2019 09:40:28 +0900
Subject: [PATCH 09/17] feat(eslint-plugin): add prefer-includes rule (#294)

Fixes #284
---
 .../docs/rules/prefer-includes.md             |  71 +++
 packages/eslint-plugin/package.json           |   2 +
 .../src/rules/prefer-includes.ts              | 209 +++++++++
 .../tests/rules/prefer-includes.test.ts       | 439 ++++++++++++++++++
 .../eslint-plugin/typings/eslint-utils.d.ts   | 178 +++++++
 packages/eslint-plugin/typings/ts-eslint.d.ts |   4 +-
 6 files changed, 902 insertions(+), 1 deletion(-)
 create mode 100644 packages/eslint-plugin/docs/rules/prefer-includes.md
 create mode 100644 packages/eslint-plugin/src/rules/prefer-includes.ts
 create mode 100644 packages/eslint-plugin/tests/rules/prefer-includes.test.ts
 create mode 100644 packages/eslint-plugin/typings/eslint-utils.d.ts

diff --git a/packages/eslint-plugin/docs/rules/prefer-includes.md b/packages/eslint-plugin/docs/rules/prefer-includes.md
new file mode 100644
index 000000000000..1ea37102b1d3
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/prefer-includes.md
@@ -0,0 +1,71 @@
+# Enforce `includes` method over `indexOf` method (@typescript-eslint/prefer-includes)
+
+Until ES5, we were using `String#indexOf` method to check whether a string contains an arbitrary substring or not.
+Until ES2015, we were using `Array#indexOf` method to check whether an array contains an arbitrary value or not.
+
+ES2015 has added `String#includes` and ES2016 has added `Array#includes`.
+It makes code more understandable if we use those `includes` methods for the purpose.
+
+## Rule Details
+
+This rule is aimed at suggesting `includes` method if `indexOf` method was used to check whether an object contains an arbitrary value or not.
+
+If the receiver object of the `indexOf` method call has `includes` method and the two methods have the same parameters, this rule does suggestion.
+There are such types: `String`, `Array`, `ReadonlyArray`, and typed arrays.
+
+Additionally, this rule reports the tests of simple regular expressions in favor of `String#includes`.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+let str: string;
+let array: any[];
+let readonlyArray: ReadonlyArray<any>;
+let typedArray: UInt8Array;
+let userDefined: {
+  indexOf(x: any): number;
+  includes(x: any): boolean;
+};
+
+str.indexOf(value) !== -1;
+array.indexOf(value) !== -1;
+readonlyArray.indexOf(value) === -1;
+typedArray.indexOf(value) > -1;
+userDefined.indexOf(value) >= 0;
+
+// simple RegExp test
+/foo/.test(str);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+let array: any[];
+let readonlyArray: ReadonlyArray<any>;
+let typedArray: UInt8Array;
+let userDefined: {
+  indexOf(x: any): number;
+  includes(x: any): boolean;
+};
+let mismatchExample: {
+  indexOf(x: any, fromIndex?: number): number;
+  includes(x: any): boolean;
+};
+
+str.includes(value);
+array.includes(value);
+readonlyArray.includes(value);
+typedArray.includes(value);
+userDefined.includes(value);
+
+// the two methods have different parameters.
+mismatchExample.indexOf(value) >= 0;
+```
+
+## Options
+
+There are no options.
+
+## When Not To Use It
+
+If you don't want to suggest `includes`, you can safely turn this rule off.
diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json
index e350e5ab9e6a..6a292d723bd2 100644
--- a/packages/eslint-plugin/package.json
+++ b/packages/eslint-plugin/package.json
@@ -37,6 +37,8 @@
   "dependencies": {
     "@typescript-eslint/parser": "1.6.0",
     "@typescript-eslint/typescript-estree": "1.6.0",
+    "eslint-utils": "^1.3.1",
+    "regexpp": "^2.0.1",
     "requireindex": "^1.2.0",
     "tsutils": "^3.7.0"
   },
diff --git a/packages/eslint-plugin/src/rules/prefer-includes.ts b/packages/eslint-plugin/src/rules/prefer-includes.ts
new file mode 100644
index 000000000000..f7b3eb153eef
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/prefer-includes.ts
@@ -0,0 +1,209 @@
+import { TSESTree } from '@typescript-eslint/typescript-estree';
+import { getStaticValue } from 'eslint-utils';
+import { AST as RegExpAST, parseRegExpLiteral } from 'regexpp';
+import ts from 'typescript';
+import { createRule, getParserServices } from '../util';
+
+export default createRule({
+  name: 'prefer-includes',
+  defaultOptions: [],
+
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforce `includes` method over `indexOf` method',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    fixable: 'code',
+    messages: {
+      preferIncludes: "Use 'includes()' method instead.",
+      preferStringIncludes:
+        'Use `String#includes()` method with a string instead.',
+    },
+    schema: [],
+  },
+
+  create(context) {
+    const globalScope = context.getScope();
+    const services = getParserServices(context);
+    const types = services.program.getTypeChecker();
+
+    function isNumber(node: TSESTree.Node, value: number): boolean {
+      const evaluated = getStaticValue(node, globalScope);
+      return evaluated !== null && evaluated.value === value;
+    }
+
+    function isPositiveCheck(node: TSESTree.BinaryExpression): boolean {
+      switch (node.operator) {
+        case '!==':
+        case '!=':
+        case '>':
+          return isNumber(node.right, -1);
+        case '>=':
+          return isNumber(node.right, 0);
+        default:
+          return false;
+      }
+    }
+    function isNegativeCheck(node: TSESTree.BinaryExpression): boolean {
+      switch (node.operator) {
+        case '===':
+        case '==':
+        case '<=':
+          return isNumber(node.right, -1);
+        case '<':
+          return isNumber(node.right, 0);
+        default:
+          return false;
+      }
+    }
+
+    function hasSameParameters(
+      nodeA: ts.Declaration,
+      nodeB: ts.Declaration,
+    ): boolean {
+      if (!ts.isFunctionLike(nodeA) || !ts.isFunctionLike(nodeB)) {
+        return false;
+      }
+
+      const paramsA = nodeA.parameters;
+      const paramsB = nodeB.parameters;
+      if (paramsA.length !== paramsB.length) {
+        return false;
+      }
+
+      for (let i = 0; i < paramsA.length; ++i) {
+        const paramA = paramsA[i];
+        const paramB = paramsB[i];
+
+        // Check name, type, and question token once.
+        if (paramA.getText() !== paramB.getText()) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    /**
+     * Parse a given node if it's a `RegExp` instance.
+     * @param node The node to parse.
+     */
+    function parseRegExp(node: TSESTree.Node): string | null {
+      const evaluated = getStaticValue(node, globalScope);
+      if (evaluated == null || !(evaluated.value instanceof RegExp)) {
+        return null;
+      }
+
+      const { pattern, flags } = parseRegExpLiteral(evaluated.value);
+      if (
+        pattern.alternatives.length !== 1 ||
+        flags.ignoreCase ||
+        flags.global
+      ) {
+        return null;
+      }
+
+      // Check if it can determine a unique string.
+      const chars = pattern.alternatives[0].elements;
+      if (!chars.every(c => c.type === 'Character')) {
+        return null;
+      }
+
+      // To string.
+      return String.fromCodePoint(
+        ...chars.map(c => (c as RegExpAST.Character).value),
+      );
+    }
+
+    return {
+      "BinaryExpression > CallExpression.left > MemberExpression.callee[property.name='indexOf'][computed=false]"(
+        node: TSESTree.MemberExpression,
+      ): void {
+        // Check if the comparison is equivalent to `includes()`.
+        const callNode = node.parent as TSESTree.CallExpression;
+        const compareNode = callNode.parent as TSESTree.BinaryExpression;
+        const negative = isNegativeCheck(compareNode);
+        if (!negative && !isPositiveCheck(compareNode)) {
+          return;
+        }
+
+        // Get the symbol of `indexOf` method.
+        const tsNode = services.esTreeNodeToTSNodeMap.get(node.property);
+        const indexofMethodSymbol = types.getSymbolAtLocation(tsNode);
+        if (
+          indexofMethodSymbol == null ||
+          indexofMethodSymbol.declarations.length === 0
+        ) {
+          return;
+        }
+
+        // Check if every declaration of `indexOf` method has `includes` method
+        // and the two methods have the same parameters.
+        for (const instanceofMethodDecl of indexofMethodSymbol.declarations) {
+          const typeDecl = instanceofMethodDecl.parent;
+          const type = types.getTypeAtLocation(typeDecl);
+          const includesMethodSymbol = type.getProperty('includes');
+          if (
+            includesMethodSymbol == null ||
+            !includesMethodSymbol.declarations.some(includesMethodDecl =>
+              hasSameParameters(includesMethodDecl, instanceofMethodDecl),
+            )
+          ) {
+            return;
+          }
+        }
+
+        // Report it.
+        context.report({
+          node: compareNode,
+          messageId: 'preferIncludes',
+          *fix(fixer) {
+            if (negative) {
+              yield fixer.insertTextBefore(callNode, '!');
+            }
+            yield fixer.replaceText(node.property, 'includes');
+            yield fixer.removeRange([callNode.range[1], compareNode.range[1]]);
+          },
+        });
+      },
+
+      // /bar/.test(foo)
+      'CallExpression > MemberExpression.callee[property.name="test"][computed=false]'(
+        node: TSESTree.MemberExpression,
+      ): void {
+        const callNode = node.parent as TSESTree.CallExpression;
+        const text =
+          callNode.arguments.length === 1 ? parseRegExp(node.object) : null;
+        if (text == null) {
+          return;
+        }
+
+        context.report({
+          node: callNode,
+          messageId: 'preferStringIncludes',
+          *fix(fixer) {
+            const argNode = callNode.arguments[0];
+            const needsParen =
+              argNode.type !== 'Literal' &&
+              argNode.type !== 'TemplateLiteral' &&
+              argNode.type !== 'Identifier' &&
+              argNode.type !== 'MemberExpression' &&
+              argNode.type !== 'CallExpression';
+
+            yield fixer.removeRange([callNode.range[0], argNode.range[0]]);
+            if (needsParen) {
+              yield fixer.insertTextBefore(argNode, '(');
+              yield fixer.insertTextAfter(argNode, ')');
+            }
+            yield fixer.insertTextAfter(
+              argNode,
+              `.includes(${JSON.stringify(text)}`,
+            );
+          },
+        });
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/tests/rules/prefer-includes.test.ts b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
new file mode 100644
index 000000000000..f754c4875211
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/prefer-includes.test.ts
@@ -0,0 +1,439 @@
+import path from 'path';
+import rule from '../../src/rules/prefer-includes';
+import { RuleTester } from '../RuleTester';
+
+const rootPath = path.join(process.cwd(), 'tests/fixtures/');
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    tsconfigRootDir: rootPath,
+    project: './tsconfig.json',
+  },
+});
+
+ruleTester.run('prefer-includes', rule, {
+  valid: [
+    `
+      function f(a: string): void {
+        a.indexOf(b)
+      }
+    `,
+    `
+      function f(a: string): void {
+        a.indexOf(b) + 0
+      }
+    `,
+    `
+      function f(a: string | {value: string}): void {
+        a.indexOf(b) !== -1
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any): number // don't have 'includes'.
+      }
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number
+        includes(x: any): boolean // different parameters.
+      }
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number
+        includes(x: any, fromIndex: number): boolean // different parameters.
+      }
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1
+      }
+    `,
+    `
+      type UserDefined = {
+        indexOf(x: any, fromIndex?: number): number
+        includes: boolean // different type.
+      }
+      function f(a: UserDefined): void {
+        a.indexOf(b) !== -1
+      }
+    `,
+    `
+      function f(a: string): void {
+        /bar/i.test(a)
+      }
+    `,
+    `
+      function f(a: string): void {
+        /ba[rz]/.test(a)
+      }
+    `,
+    `
+      function f(a: string): void {
+        /foo|bar/.test(a)
+      }
+    `,
+    `
+      function f(a: string): void {
+        /bar/.test()
+      }
+    `,
+    `
+      function f(a: string): void {
+        something.test(a)
+      }
+    `,
+  ],
+  invalid: [
+    // positive
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) != -1
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) > -1
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) >= 0
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+
+    // negative
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) === -1
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          !a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) == -1
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          !a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) <= -1
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          !a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: string): void {
+          a.indexOf(b) < 0
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          !a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+
+    // RegExp#test
+    {
+      code: `
+        function f(a: string): void {
+          /bar/.test(a)
+        }
+      `,
+      output: `
+        function f(a: string): void {
+          a.includes("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStringIncludes' }],
+    },
+    {
+      code: `
+        const pattern = new RegExp("bar")
+        function f(a: string): void {
+          pattern.test(a)
+        }
+      `,
+      output: `
+        const pattern = new RegExp("bar")
+        function f(a: string): void {
+          a.includes("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStringIncludes' }],
+    },
+    {
+      code: `
+        const pattern = /bar/
+        function f(a: string, b: string): void {
+          pattern.test(a + b)
+        }
+      `,
+      output: `
+        const pattern = /bar/
+        function f(a: string, b: string): void {
+          (a + b).includes("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStringIncludes' }],
+    },
+
+    // type variation
+    {
+      code: `
+        function f(a: any[]): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: any[]): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: ReadonlyArray<any>): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: ReadonlyArray<any>): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Int8Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Int8Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Int16Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Int16Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Int32Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Int32Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Uint8Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Uint8Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Uint16Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Uint16Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Uint32Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Uint32Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Float32Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Float32Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Float64Array): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Float64Array): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f<T>(a: T[] | ReadonlyArray<T>): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f<T>(a: T[] | ReadonlyArray<T>): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f<T, U extends T[] | ReadonlyArray<T> | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array>(a: U): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f<T, U extends T[] | ReadonlyArray<T> | Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array>(a: U): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        type UserDefined = {
+          indexOf(x: any): number
+          includes(x: any): boolean
+        }
+        function f(a: UserDefined): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        type UserDefined = {
+          indexOf(x: any): number
+          includes(x: any): boolean
+        }
+        function f(a: UserDefined): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+    {
+      code: `
+        function f(a: Readonly<any[]>): void {
+          a.indexOf(b) !== -1
+        }
+      `,
+      output: `
+        function f(a: Readonly<any[]>): void {
+          a.includes(b)
+        }
+      `,
+      errors: [{ messageId: 'preferIncludes' }],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin/typings/eslint-utils.d.ts b/packages/eslint-plugin/typings/eslint-utils.d.ts
new file mode 100644
index 000000000000..d926229b00ea
--- /dev/null
+++ b/packages/eslint-plugin/typings/eslint-utils.d.ts
@@ -0,0 +1,178 @@
+declare module 'eslint-utils' {
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
+  import { Scope, SourceCode } from 'ts-eslint';
+
+  export function getFunctionHeadLocation(
+    node:
+      | TSESTree.FunctionDeclaration
+      | TSESTree.FunctionExpression
+      | TSESTree.ArrowFunctionExpression,
+    sourceCode: SourceCode,
+  ): TSESTree.SourceLocation;
+
+  export function getFunctionNameWithKind(
+    node:
+      | TSESTree.FunctionDeclaration
+      | TSESTree.FunctionExpression
+      | TSESTree.ArrowFunctionExpression,
+  ): string;
+
+  export function getPropertyName(
+    node:
+      | TSESTree.MemberExpression
+      | TSESTree.Property
+      | TSESTree.MethodDefinition,
+    initialScope?: Scope.Scope,
+  ): string | null;
+
+  export function getStaticValue(
+    node: TSESTree.Node,
+    initialScope?: Scope.Scope,
+  ): { value: any } | null;
+
+  export function getStringIfConstant(
+    node: TSESTree.Node,
+    initialScope?: Scope.Scope,
+  ): string | null;
+
+  export function hasSideEffect(
+    node: TSESTree.Node,
+    sourceCode: SourceCode,
+    options?: {
+      considerGetters?: boolean;
+      considerImplicitTypeConversion?: boolean;
+    },
+  ): boolean;
+
+  export function isParenthesized(
+    node: TSESTree.Node,
+    sourceCode: SourceCode,
+  ): boolean;
+
+  export class PatternMatcher {
+    constructor(pattern: RegExp, options?: { escaped?: boolean });
+    execAll(str: string): IterableIterator<RegExpExecArray>;
+    test(str: string): boolean;
+  }
+
+  export function findVariable(
+    initialScope: Scope.Scope,
+    name: string,
+  ): Scope.Variable | null;
+
+  export function getInnermostScope(
+    initialScope: Scope.Scope,
+    node: TSESTree.Node,
+  ): Scope.Scope;
+
+  export class ReferenceTracker {
+    static readonly READ: unique symbol;
+    static readonly CALL: unique symbol;
+    static readonly CONSTRUCT: unique symbol;
+
+    constructor(
+      globalScope: Scope.Scope,
+      options?: {
+        mode: 'strict' | 'legacy';
+        globalObjectNames: ReadonlyArray<string>;
+      },
+    );
+
+    iterateGlobalReferences<T>(
+      traceMap: ReferenceTracker.TraceMap<T>,
+    ): IterableIterator<ReferenceTracker.FoundReference<T>>;
+    iterateCjsReferences<T>(
+      traceMap: ReferenceTracker.TraceMap<T>,
+    ): IterableIterator<ReferenceTracker.FoundReference<T>>;
+    iterateEsmReferences<T>(
+      traceMap: ReferenceTracker.TraceMap<T>,
+    ): IterableIterator<ReferenceTracker.FoundReference<T>>;
+  }
+
+  export namespace ReferenceTracker {
+    export type READ = typeof ReferenceTracker.READ;
+    export type CALL = typeof ReferenceTracker.READ;
+    export type CONSTRUCT = typeof ReferenceTracker.READ;
+    export type ReferenceType = READ | CALL | CONSTRUCT;
+    export type TraceMap<T = any> = Record<string, TraceMapElement<T>>;
+    export interface TraceMapElement<T> {
+      [ReferenceTracker.READ]?: T;
+      [ReferenceTracker.CALL]?: T;
+      [ReferenceTracker.CONSTRUCT]?: T;
+      [key: string]: TraceMapElement<T>;
+    }
+    export interface FoundReference<T = any> {
+      node: TSESTree.Node;
+      path: ReadonlyArray<string>;
+      type: ReferenceType;
+      entry: T;
+    }
+  }
+
+  export function isArrowToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotArrowToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isClosingBraceToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotClosingBraceToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isClosingBracketToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotClosingBracketToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isClosingParenToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotClosingParenToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isColonToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotColonToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isCommaToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotCommaToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isCommentToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotCommentToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isOpeningBraceToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotOpeningBraceToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isOpeningBracketToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotOpeningBracketToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isOpeningParenToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotOpeningParenToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isSemicolonToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+  export function isNotSemicolonToken(
+    token: TSESTree.Token | TSESTree.Comment,
+  ): boolean;
+}
diff --git a/packages/eslint-plugin/typings/ts-eslint.d.ts b/packages/eslint-plugin/typings/ts-eslint.d.ts
index 33b667dab46a..d6bd1eef8a7c 100644
--- a/packages/eslint-plugin/typings/ts-eslint.d.ts
+++ b/packages/eslint-plugin/typings/ts-eslint.d.ts
@@ -297,7 +297,9 @@ declare module 'ts-eslint' {
     replaceTextRange(range: AST.Range, text: string): RuleFix;
   }
 
-  type ReportFixFunction = (fixer: RuleFixer) => null | RuleFix | RuleFix[];
+  type ReportFixFunction = (
+    fixer: RuleFixer,
+  ) => null | RuleFix | Iterable<RuleFix>;
 
   interface ReportDescriptor<TMessageIds extends string> {
     /**

From 53113421d85b94be6518cea35dca6d1211436961 Mon Sep 17 00:00:00 2001
From: Josh Goldberg <joshuakgoldberg@outlook.com>
Date: Wed, 10 Apr 2019 20:59:47 -0400
Subject: [PATCH 10/17] feat(eslint-plugin): added new rule await-promise
 (#192)

---
 packages/eslint-plugin/README.md              |   1 +
 packages/eslint-plugin/ROADMAP.md             |   3 +-
 .../docs/rules/await-thenable.md              |  33 +++
 .../eslint-plugin/src/rules/await-thenable.ts |  47 ++++
 .../tests/rules/await-thenable.test.ts        | 223 ++++++++++++++++++
 5 files changed, 306 insertions(+), 1 deletion(-)
 create mode 100644 packages/eslint-plugin/docs/rules/await-thenable.md
 create mode 100644 packages/eslint-plugin/src/rules/await-thenable.ts
 create mode 100644 packages/eslint-plugin/tests/rules/await-thenable.test.ts

diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
index 22754a977c4d..00d11b528344 100644
--- a/packages/eslint-plugin/README.md
+++ b/packages/eslint-plugin/README.md
@@ -112,6 +112,7 @@ Then you should add `airbnb` (or `airbnb-base`) to your `extends` section of `.e
 | --------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | -------- | ----------------- |
 | [`@typescript-eslint/adjacent-overload-signatures`](./docs/rules/adjacent-overload-signatures.md)         | Require that member overloads be consecutive (`adjacent-overload-signatures` from TSLint)                                                           | :heavy_check_mark: |          |                   |
 | [`@typescript-eslint/array-type`](./docs/rules/array-type.md)                                             | Requires using either `T[]` or `Array<T>` for arrays (`array-type` from TSLint)                                                                     | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/await-thenable`](./docs/rules/await-thenable.md)                                     | Disallow awaiting a value that is not a Promise (`await-promise` from TSLint)                                                                       | :heavy_check_mark: |          | :thought_balloon: |
 | [`@typescript-eslint/ban-types`](./docs/rules/ban-types.md)                                               | Enforces that types will not to be used (`ban-types` from TSLint)                                                                                   | :heavy_check_mark: | :wrench: |                   |
 | [`@typescript-eslint/ban-ts-ignore`](./docs/rules/ban-ts-ignore.md)                                       | Bans “// @ts-ignore” comments from being used (`ban-ts-ignore` from TSLint)                                                                         |                    |          |                   |
 | [`@typescript-eslint/camelcase`](./docs/rules/camelcase.md)                                               | Enforce camelCase naming convention                                                                                                                 | :heavy_check_mark: |          |                   |
diff --git a/packages/eslint-plugin/ROADMAP.md b/packages/eslint-plugin/ROADMAP.md
index 6df8aa7fe31c..9622f367f577 100644
--- a/packages/eslint-plugin/ROADMAP.md
+++ b/packages/eslint-plugin/ROADMAP.md
@@ -40,7 +40,7 @@
 
 | TSLint rule                          |     | ESLint rule                                                           |
 | ------------------------------------ | :-: | --------------------------------------------------------------------- |
-| [`await-promise`]                    | 🛑  | N/A                                                                   |
+| [`await-promise`]                    | ✅  | [`@typescript-eslint/await-thenable`]                                 |
 | [`ban-comma-operator`]               | 🌟  | [`no-sequences`][no-sequences]                                        |
 | [`ban`]                              | 🌟  | [`no-restricted-properties`][no-restricted-properties]                |
 | [`curly`]                            | 🌟  | [`curly`][curly]                                                      |
@@ -574,6 +574,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint-
 <!-- @typescript-eslint/eslint-plugin -->
 
 [`@typescript-eslint/adjacent-overload-signatures`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/adjacent-overload-signatures.md
+[`@typescript-eslint/await-thenable`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/await-thenable.md
 [`@typescript-eslint/ban-types`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/ban-types.md
 [`@typescript-eslint/ban-ts-ignore`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/ban-ts-ignore.md
 [`@typescript-eslint/explicit-member-accessibility`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/explicit-member-accessibility.md
diff --git a/packages/eslint-plugin/docs/rules/await-thenable.md b/packages/eslint-plugin/docs/rules/await-thenable.md
new file mode 100644
index 000000000000..47780d1db42d
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/await-thenable.md
@@ -0,0 +1,33 @@
+# Disallows awaiting a value that is not a Promise (await-thenable)
+
+This rule disallows awaiting a value that is not a "Thenable" (an object which has `then` method, such as a Promise).
+While it is valid JavaScript to await a non-`Promise`-like value (it will resolve immediately), this pattern is often a programmer error, such as forgetting to add parenthesis to call a function that returns a Promise.
+
+## Rule Details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+await 'value';
+
+const createValue = () => 'value';
+await createValue();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+await Promise.resolve('value');
+
+const createValue = async () => 'value';
+await createValue();
+```
+
+## When Not To Use It
+
+If you want to allow code to `await` non-Promise values.
+This is generally not preferred, but can sometimes be useful for visual consistency.
+
+## Related to
+
+- TSLint: ['await-promise'](https://palantir.github.io/tslint/rules/await-promise)
diff --git a/packages/eslint-plugin/src/rules/await-thenable.ts b/packages/eslint-plugin/src/rules/await-thenable.ts
new file mode 100644
index 000000000000..a52469ef6e33
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/await-thenable.ts
@@ -0,0 +1,47 @@
+import * as tsutils from 'tsutils';
+import * as ts from 'typescript';
+
+import * as util from '../util';
+
+export default util.createRule({
+  name: 'await-thenable',
+  meta: {
+    docs: {
+      description: 'Disallows awaiting a value that is not a Thenable',
+      category: 'Best Practices',
+      recommended: 'error',
+      tslintName: 'await-thenable',
+    },
+    messages: {
+      await: 'Unexpected `await` of a non-Promise (non-"Thenable") value.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  defaultOptions: [],
+
+  create(context) {
+    const parserServices = util.getParserServices(context);
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      AwaitExpression(node) {
+        const originalNode = parserServices.esTreeNodeToTSNodeMap.get(
+          node,
+        ) as ts.AwaitExpression;
+        const type = checker.getTypeAtLocation(originalNode.expression);
+
+        if (
+          !tsutils.isTypeFlagSet(type, ts.TypeFlags.Any) &&
+          !tsutils.isTypeFlagSet(type, ts.TypeFlags.Unknown) &&
+          !tsutils.isThenableType(checker, originalNode.expression, type)
+        ) {
+          context.report({
+            messageId: 'await',
+            node,
+          });
+        }
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/tests/rules/await-thenable.test.ts b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
new file mode 100644
index 000000000000..deca521aefa8
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
@@ -0,0 +1,223 @@
+import rule from '../../src/rules/await-thenable';
+import { RuleTester, getFixturesRootDir } from '../RuleTester';
+
+const rootDir = getFixturesRootDir();
+const parserOptions = {
+  ecmaVersion: 2018,
+  tsconfigRootDir: rootDir,
+  project: './tsconfig.json',
+};
+
+const messageId = 'await';
+
+const ruleTester = new RuleTester({
+  parserOptions,
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('await-promise', rule, {
+  valid: [
+    `
+async function test() {
+  await Promise.resolve("value");
+  await Promise.reject(new Error("message"));
+}
+`,
+    `
+async function test() {
+  await (async () => true)();
+}
+`,
+    `
+async function test() {
+  function returnsPromise() {
+    return Promise.resolve("value");
+  }
+  await returnsPromise();
+}
+`,
+    `
+async function test() {
+  async function returnsPromiseAsync() {}
+  await returnsPromiseAsync();
+}
+`,
+    `
+async function test() {
+  let anyValue: any;
+  await anyValue;
+}
+`,
+    `
+async function test() {
+  let unknownValue: unknown;
+  await unknownValue;
+}
+`,
+    `
+async function test() {
+  const numberPromise: Promise<number>;
+  await numberPromise;
+}
+`,
+    `
+async function test() {
+  class Foo extends Promise<number> {}
+  const foo: Foo = Foo.resolve(2);
+  await foo;
+
+  class Bar extends Foo {}
+  const bar: Bar = Bar.resolve(2);
+  await bar;
+}
+`,
+    `
+async function test() {
+  await (Math.random() > 0.5 ? numberPromise : 0);
+  await (Math.random() > 0.5 ? foo : 0);
+  await (Math.random() > 0.5 ? bar : 0);
+
+  const intersectionPromise: Promise<number> & number;
+  await intersectionPromise;
+}
+`,
+    `
+async function test() {
+  class Thenable { then(callback: () => {}) { } };
+  const thenable = new Thenable();
+
+  await thenable;
+}
+`,
+    `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
+// Type definitions for promise-polyfill 6.0
+// Project: https://github.com/taylorhakes/promise-polyfill
+// Definitions by: Steve Jenkins <https://github.com/skysteve>
+//                 Daniel Cassidy <https://github.com/djcsdy>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface PromisePolyfillConstructor extends PromiseConstructor {
+    _immediateFn?: (handler: (() => void) | string) => void;
+}
+
+declare const PromisePolyfill: PromisePolyfillConstructor;
+
+async function test() {
+  const promise = new PromisePolyfill(() => {});
+
+  await promise;
+}
+`,
+    `
+// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/bluebird/index.d.ts
+// Type definitions for bluebird 3.5
+// Project: https://github.com/petkaantonov/bluebird
+// Definitions by: Leonard Hecker <https://github.com/lhecker>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+/*!
+ * The code following this comment originates from:
+ *   https://github.com/types/npm-bluebird
+ *
+ * Note for browser users: use bluebird-global typings instead of this one
+ * if you want to use Bluebird via the global Promise symbol.
+ *
+ * Licensed under:
+ *   The MIT License (MIT)
+ *
+ *   Copyright (c) 2016 unional
+ *
+ *   Permission is hereby granted, free of charge, to any person obtaining a copy
+ *   of this software and associated documentation files (the "Software"), to deal
+ *   in the Software without restriction, including without limitation the rights
+ *   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *   copies of the Software, and to permit persons to whom the Software is
+ *   furnished to do so, subject to the following conditions:
+ *
+ *   The above copyright notice and this permission notice shall be included in
+ *   all copies or substantial portions of the Software.
+ *
+ *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *   THE SOFTWARE.
+ */
+
+type Constructor<E> = new (...args: any[]) => E;
+type CatchFilter<E> = ((error: E) => boolean) | (object & E);
+type IterableItem<R> = R extends Iterable<infer U> ? U : never;
+type IterableOrNever<R> = Extract<R, Iterable<any>>;
+type Resolvable<R> = R | PromiseLike<R>;
+type IterateFunction<T, R> = (item: T, index: number, arrayLength: number) => Resolvable<R>;
+
+declare class Bluebird<R> implements PromiseLike<R> {
+  then<U>(onFulfill?: (value: R) => Resolvable<U>, onReject?: (error: any) => Resolvable<U>): Bluebird<U>; // For simpler signature help.
+  then<TResult1 = R, TResult2 = never>(
+      onfulfilled?: ((value: R) => Resolvable<TResult1>) | null,
+      onrejected?: ((reason: any) => Resolvable<TResult2>) | null
+    ): Bluebird<TResult1 | TResult2>;
+}
+
+declare const bluebird: Bluebird;
+
+async function test() {
+  await bluebird;
+}
+`,
+  ],
+
+  invalid: [
+    {
+      code: `
+async function test() {
+  await 0;
+  await "value";
+
+  await (Math.random() > 0.5 ? "" : 0);
+
+  class NonPromise extends Array {}
+  await new NonPromise();
+}
+`,
+      errors: [
+        {
+          line: 3,
+          messageId,
+        },
+        {
+          line: 4,
+          messageId,
+        },
+        {
+          line: 6,
+          messageId,
+        },
+        {
+          line: 9,
+          messageId,
+        },
+      ],
+    },
+    {
+      code: `
+async function test() {
+  class IncorrectThenable { then() { } };
+  const thenable = new IncorrectThenable();
+
+  await thenable;
+}
+      `,
+      errors: [
+        {
+          line: 6,
+          messageId,
+        },
+      ],
+    },
+  ],
+});

From 5592a2ca04c14c934cf4c204046572ee26bb067f Mon Sep 17 00:00:00 2001
From: Toru Nagashima <star.ctor@gmail.com>
Date: Thu, 11 Apr 2019 10:18:44 +0900
Subject: [PATCH 11/17] feat(eslint-plugin): add prefer-string-starts-ends-with
 rule (#289)

Fixes #285
---
 .../rules/prefer-string-starts-ends-with.md   |   54 +
 .../rules/prefer-string-starts-ends-with.ts   |  645 ++++++++++
 packages/eslint-plugin/tests/RuleTester.ts    |    2 +-
 .../prefer-string-starts-ends-with.test.ts    | 1046 +++++++++++++++++
 packages/eslint-plugin/typings/ts-eslint.d.ts |    3 +-
 5 files changed, 1748 insertions(+), 2 deletions(-)
 create mode 100644 packages/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md
 create mode 100644 packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
 create mode 100644 packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts

diff --git a/packages/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md b/packages/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md
new file mode 100644
index 000000000000..07ad4e1148fb
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md
@@ -0,0 +1,54 @@
+# Enforce the use of `String#startsWith` and `String#endsWith` instead of other equivalent methods of checking substrings (prefer-string-starts-ends-with)
+
+There are multiple ways to verify if a string starts or ends with a specific string, such as `foo.indexOf('bar') === 0`.
+
+Since ES2015 has added `String#startsWith` and `String#endsWith`, this rule reports other ways to be consistent.
+
+## Rule Details
+
+This rule is aimed at enforcing a consistent way to check whether a string starts or ends with a specific string.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+let foo: string;
+
+// starts with
+foo[0] === 'b';
+foo.charAt(0) === 'b';
+foo.indexOf('bar') === 0;
+foo.slice(0, 3) === 'bar';
+foo.substring(0, 3) === 'bar';
+foo.match(/^bar/) != null;
+/^bar/.test(foo);
+
+// ends with
+foo[foo.length - 1] === 'b';
+foo.charAt(foo.length - 1) === 'b';
+foo.lastIndexOf('bar') === foo.length - 3;
+foo.slice(-3) === 'bar';
+foo.substring(foo.length - 3) === 'bar';
+foo.match(/bar$/) != null;
+/bar$/.test(foo);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+foo.startsWith('bar');
+foo.endsWith('bar');
+```
+
+## Options
+
+There are no options.
+
+```JSON
+{
+    "@typescript-eslint/prefer-string-starts-ends-with": "error"
+}
+```
+
+## When Not To Use It
+
+If you don't mind that style, you can turn this rule off safely.
diff --git a/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
new file mode 100644
index 000000000000..6b3079cdfdf3
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/prefer-string-starts-ends-with.ts
@@ -0,0 +1,645 @@
+import { TSESTree } from '@typescript-eslint/typescript-estree';
+import {
+  isNotClosingParenToken,
+  getPropertyName,
+  getStaticValue,
+} from 'eslint-utils';
+import { RegExpParser, AST as RegExpAST } from 'regexpp';
+import { RuleFixer, RuleFix } from 'ts-eslint';
+import ts from 'typescript';
+import { createRule, getParserServices } from '../util';
+
+const EQ_OPERATORS = /^[=!]=/;
+const regexpp = new RegExpParser();
+
+export default createRule({
+  name: 'prefer-string-starts-ends-with',
+  defaultOptions: [],
+
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'enforce the use of `String#startsWith` and `String#endsWith` instead of other equivalent methods of checking substrings',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    messages: {
+      preferStartsWith: "Use 'String#startsWith' method instead.",
+      preferEndsWith: "Use the 'String#endsWith' method instead.",
+    },
+    schema: [],
+    fixable: 'code',
+  },
+
+  create(context) {
+    const globalScope = context.getScope();
+    const sourceCode = context.getSourceCode();
+    const service = getParserServices(context);
+    const types = service.program.getTypeChecker();
+
+    /**
+     * Get the type name of a given type.
+     * @param type The type to get.
+     */
+    function getTypeName(type: ts.Type): string {
+      // It handles `string` and string literal types as string.
+      if ((type.flags & ts.TypeFlags.StringLike) !== 0) {
+        return 'string';
+      }
+
+      // If the type is a type parameter which extends primitive string types,
+      // but it was not recognized as a string like. So check the constraint
+      // type of the type parameter.
+      if ((type.flags & ts.TypeFlags.TypeParameter) !== 0) {
+        // `type.getConstraint()` method doesn't return the constraint type of
+        // the type parameter for some reason. So this gets the constraint type
+        // via AST.
+        const node = type.symbol.declarations[0] as ts.TypeParameterDeclaration;
+        if (node.constraint != null) {
+          return getTypeName(types.getTypeFromTypeNode(node.constraint));
+        }
+      }
+
+      // If the type is a union and all types in the union are string like,
+      // return `string`. For example:
+      // - `"a" | "b"` is string.
+      // - `string | string[]` is not string.
+      if (
+        type.isUnion() &&
+        type.types.map(getTypeName).every(t => t === 'string')
+      ) {
+        return 'string';
+      }
+
+      // If the type is an intersection and a type in the intersection is string
+      // like, return `string`. For example: `string & {__htmlEscaped: void}`
+      if (
+        type.isIntersection() &&
+        type.types.map(getTypeName).some(t => t === 'string')
+      ) {
+        return 'string';
+      }
+
+      return types.typeToString(type);
+    }
+
+    /**
+     * Check if a given node is a string.
+     * @param node The node to check.
+     */
+    function isStringType(node: TSESTree.Node): boolean {
+      const objectType = types.getTypeAtLocation(
+        service.esTreeNodeToTSNodeMap.get(node),
+      );
+      const typeName = getTypeName(objectType);
+
+      return typeName === 'string';
+    }
+
+    /**
+     * Check if a given node is a `Literal` node that is null.
+     * @param node The node to check.
+     */
+    function isNull(node: TSESTree.Node): node is TSESTree.Literal {
+      const evaluated = getStaticValue(node, globalScope);
+      return evaluated != null && evaluated.value === null;
+    }
+
+    /**
+     * Check if a given node is a `Literal` node that is a given value.
+     * @param node The node to check.
+     * @param value The expected value of the `Literal` node.
+     */
+    function isNumber(
+      node: TSESTree.Node,
+      value: number,
+    ): node is TSESTree.Literal {
+      const evaluated = getStaticValue(node, globalScope);
+      return evaluated != null && evaluated.value === value;
+    }
+
+    /**
+     * Check if a given node is a `Literal` node that is a character.
+     * @param node The node to check.
+     * @param kind The method name to get a character.
+     */
+    function isCharacter(node: TSESTree.Node): node is TSESTree.Literal {
+      const evaluated = getStaticValue(node, globalScope);
+      return (
+        evaluated != null &&
+        typeof evaluated.value === 'string' &&
+        evaluated.value[0] === evaluated.value
+      );
+    }
+
+    /**
+     * Check if a given node is `==`, `===`, `!=`, or `!==`.
+     * @param node The node to check.
+     */
+    function isEqualityComparison(
+      node: TSESTree.Node,
+    ): node is TSESTree.BinaryExpression {
+      return (
+        node.type === 'BinaryExpression' && EQ_OPERATORS.test(node.operator)
+      );
+    }
+
+    /**
+     * Check if two given nodes are the same meaning.
+     * @param node1 A node to compare.
+     * @param node2 Another node to compare.
+     */
+    function isSameTokens(node1: TSESTree.Node, node2: TSESTree.Node): boolean {
+      const tokens1 = sourceCode.getTokens(node1);
+      const tokens2 = sourceCode.getTokens(node2);
+
+      if (tokens1.length !== tokens2.length) {
+        return false;
+      }
+
+      for (let i = 0; i < tokens1.length; ++i) {
+        const token1 = tokens1[i];
+        const token2 = tokens2[i];
+
+        if (token1.type !== token2.type || token1.value !== token2.value) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    /**
+     * Check if a given node is the expression of the length of a string.
+     *
+     * - If `length` property access of `expectedObjectNode`, it's `true`.
+     *   E.g., `foo` → `foo.length` / `"foo"` → `"foo".length`
+     * - If `expectedObjectNode` is a string literal, `node` can be a number.
+     *   E.g., `"foo"` → `3`
+     *
+     * @param node The node to check.
+     * @param expectedObjectNode The node which is expected as the receiver of `length` property.
+     */
+    function isLengthExpression(
+      node: TSESTree.Node,
+      expectedObjectNode: TSESTree.Node,
+    ): boolean {
+      if (node.type === 'MemberExpression') {
+        return (
+          getPropertyName(node, globalScope) === 'length' &&
+          isSameTokens(node.object, expectedObjectNode)
+        );
+      }
+
+      const evaluatedLength = getStaticValue(node, globalScope);
+      const evaluatedString = getStaticValue(expectedObjectNode, globalScope);
+      return (
+        evaluatedLength != null &&
+        evaluatedString != null &&
+        typeof evaluatedLength.value === 'number' &&
+        typeof evaluatedString.value === 'string' &&
+        evaluatedLength.value === evaluatedString.value.length
+      );
+    }
+
+    /**
+     * Check if a given node is the expression of the last index.
+     *
+     * E.g. `foo.length - 1`
+     *
+     * @param node The node to check.
+     * @param expectedObjectNode The node which is expected as the receiver of `length` property.
+     */
+    function isLastIndexExpression(
+      node: TSESTree.Node,
+      expectedObjectNode: TSESTree.Node,
+    ): boolean {
+      return (
+        node.type === 'BinaryExpression' &&
+        node.operator === '-' &&
+        isLengthExpression(node.left, expectedObjectNode) &&
+        isNumber(node.right, 1)
+      );
+    }
+
+    /**
+     * Get the range of the property of a given `MemberExpression` node.
+     *
+     * - `obj[foo]` → the range of `[foo]`
+     * - `obf.foo` → the range of `.foo`
+     * - `(obj).foo` → the range of `.foo`
+     *
+     * @param node The member expression node to get.
+     */
+    function getPropertyRange(
+      node: TSESTree.MemberExpression,
+    ): [number, number] {
+      const dotOrOpenBracket = sourceCode.getTokenAfter(
+        node.object,
+        isNotClosingParenToken,
+      )!;
+      return [dotOrOpenBracket.range[0], node.range[1]];
+    }
+
+    /**
+     * Parse a given `RegExp` pattern to that string if it's a static string.
+     * @param pattern The RegExp pattern text to parse.
+     * @param uFlag The Unicode flag of the RegExp.
+     */
+    function parseRegExpText(pattern: string, uFlag: boolean): string | null {
+      // Parse it.
+      const ast = regexpp.parsePattern(pattern, undefined, undefined, uFlag);
+      if (ast.alternatives.length !== 1) {
+        return null;
+      }
+
+      // Drop `^`/`$` assertion.
+      const chars = ast.alternatives[0].elements;
+      const first = chars[0];
+      if (first.type === 'Assertion' && first.kind === 'start') {
+        chars.shift();
+      } else {
+        chars.pop();
+      }
+
+      // Check if it can determine a unique string.
+      if (!chars.every(c => c.type === 'Character')) {
+        return null;
+      }
+
+      // To string.
+      return String.fromCodePoint(
+        ...chars.map(c => (c as RegExpAST.Character).value),
+      );
+    }
+
+    /**
+     * Parse a given node if it's a `RegExp` instance.
+     * @param node The node to parse.
+     */
+    function parseRegExp(
+      node: TSESTree.Node,
+    ): { isStartsWith: boolean; isEndsWith: boolean; text: string } | null {
+      const evaluated = getStaticValue(node, globalScope);
+      if (evaluated == null || !(evaluated.value instanceof RegExp)) {
+        return null;
+      }
+
+      const { source, flags } = evaluated.value;
+      const isStartsWith = source.startsWith('^');
+      const isEndsWith = source.endsWith('$');
+      if (
+        isStartsWith === isEndsWith ||
+        flags.includes('i') ||
+        flags.includes('m')
+      ) {
+        return null;
+      }
+
+      const text = parseRegExpText(source, flags.includes('u'));
+      if (text == null) {
+        return null;
+      }
+
+      return { isEndsWith, isStartsWith, text };
+    }
+
+    /**
+     * Fix code with using the right operand as the search string.
+     * For example: `foo.slice(0, 3) === 'bar'` → `foo.startsWith('bar')`
+     * @param fixer The rule fixer.
+     * @param node The node which was reported.
+     * @param kind The kind of the report.
+     * @param negative The flag to fix to negative condition.
+     */
+    function* fixWithRightOperand(
+      fixer: RuleFixer,
+      node: TSESTree.BinaryExpression,
+      kind: 'start' | 'end',
+      negative: boolean,
+    ): IterableIterator<RuleFix> {
+      // left is CallExpression or MemberExpression.
+      const leftNode = (node.left.type === 'CallExpression'
+        ? node.left.callee
+        : node.left) as TSESTree.MemberExpression;
+      const propertyRange = getPropertyRange(leftNode);
+
+      if (negative) {
+        yield fixer.insertTextBefore(node, '!');
+      }
+      yield fixer.replaceTextRange(
+        [propertyRange[0], node.right.range[0]],
+        `.${kind}sWith(`,
+      );
+      yield fixer.replaceTextRange([node.right.range[1], node.range[1]], ')');
+    }
+
+    /**
+     * Fix code with using the first argument as the search string.
+     * For example: `foo.indexOf('bar') === 0` → `foo.startsWith('bar')`
+     * @param fixer The rule fixer.
+     * @param node The node which was reported.
+     * @param kind The kind of the report.
+     * @param negative The flag to fix to negative condition.
+     */
+    function* fixWithArgument(
+      fixer: RuleFixer,
+      node: TSESTree.BinaryExpression,
+      kind: 'start' | 'end',
+      negative: boolean,
+    ): IterableIterator<RuleFix> {
+      const callNode = node.left as TSESTree.CallExpression;
+      const calleeNode = callNode.callee as TSESTree.MemberExpression;
+
+      if (negative) {
+        yield fixer.insertTextBefore(node, '!');
+      }
+      yield fixer.replaceTextRange(
+        getPropertyRange(calleeNode),
+        `.${kind}sWith`,
+      );
+      yield fixer.removeRange([callNode.range[1], node.range[1]]);
+    }
+
+    return {
+      // foo[0] === "a"
+      // foo.charAt(0) === "a"
+      // foo[foo.length - 1] === "a"
+      // foo.charAt(foo.length - 1) === "a"
+      [String([
+        'BinaryExpression > MemberExpression.left[computed=true]',
+        'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="charAt"][computed=false]',
+      ])](node: TSESTree.MemberExpression): void {
+        let parentNode = node.parent!;
+        let indexNode: TSESTree.Node | null = null;
+        if (parentNode.type === 'CallExpression') {
+          if (parentNode.arguments.length === 1) {
+            indexNode = parentNode.arguments[0];
+          }
+          parentNode = parentNode.parent!;
+        } else {
+          indexNode = node.property;
+        }
+
+        if (
+          indexNode == null ||
+          !isEqualityComparison(parentNode) ||
+          !isStringType(node.object)
+        ) {
+          return;
+        }
+
+        const isEndsWith = isLastIndexExpression(indexNode, node.object);
+        const isStartsWith = !isEndsWith && isNumber(indexNode, 0);
+        if (!isStartsWith && !isEndsWith) {
+          return;
+        }
+
+        const eqNode = parentNode;
+        context.report({
+          node: parentNode,
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
+          fix(fixer) {
+            // Don't fix if it can change the behavior.
+            if (!isCharacter(eqNode.right)) {
+              return null;
+            }
+            return fixWithRightOperand(
+              fixer,
+              eqNode,
+              isStartsWith ? 'start' : 'end',
+              eqNode.operator.startsWith('!'),
+            );
+          },
+        });
+      },
+
+      // foo.indexOf('bar') === 0
+      'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="indexOf"][computed=false]'(
+        node: TSESTree.MemberExpression,
+      ): void {
+        const callNode = node.parent! as TSESTree.CallExpression;
+        const parentNode = callNode.parent!;
+
+        if (
+          callNode.arguments.length !== 1 ||
+          !isEqualityComparison(parentNode) ||
+          parentNode.left !== callNode ||
+          !isNumber(parentNode.right, 0) ||
+          !isStringType(node.object)
+        ) {
+          return;
+        }
+
+        context.report({
+          node: parentNode,
+          messageId: 'preferStartsWith',
+          fix(fixer) {
+            return fixWithArgument(
+              fixer,
+              parentNode,
+              'start',
+              parentNode.operator.startsWith('!'),
+            );
+          },
+        });
+      },
+
+      // foo.lastIndexOf('bar') === foo.length - 3
+      // foo.lastIndexOf(bar) === foo.length - bar.length
+      'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="lastIndexOf"][computed=false]'(
+        node: TSESTree.MemberExpression,
+      ): void {
+        const callNode = node.parent! as TSESTree.CallExpression;
+        const parentNode = callNode.parent!;
+
+        if (
+          callNode.arguments.length !== 1 ||
+          !isEqualityComparison(parentNode) ||
+          parentNode.left !== callNode ||
+          parentNode.right.type !== 'BinaryExpression' ||
+          parentNode.right.operator !== '-' ||
+          !isLengthExpression(parentNode.right.left, node.object) ||
+          !isLengthExpression(parentNode.right.right, callNode.arguments[0]) ||
+          !isStringType(node.object)
+        ) {
+          return;
+        }
+
+        context.report({
+          node: parentNode,
+          messageId: 'preferEndsWith',
+          fix(fixer) {
+            return fixWithArgument(
+              fixer,
+              parentNode,
+              'end',
+              parentNode.operator.startsWith('!'),
+            );
+          },
+        });
+      },
+
+      // foo.match(/^bar/) === null
+      // foo.match(/bar$/) === null
+      'BinaryExpression > CallExpression.left > MemberExpression.callee[property.name="match"][computed=false]'(
+        node: TSESTree.MemberExpression,
+      ): void {
+        const callNode = node.parent as TSESTree.CallExpression;
+        const parentNode = callNode.parent as TSESTree.BinaryExpression;
+        if (
+          !isEqualityComparison(parentNode) ||
+          !isNull(parentNode.right) ||
+          !isStringType(node.object)
+        ) {
+          return;
+        }
+
+        const parsed =
+          callNode.arguments.length === 1
+            ? parseRegExp(callNode.arguments[0])
+            : null;
+        if (parsed == null) {
+          return;
+        }
+
+        const { isStartsWith, text } = parsed;
+        context.report({
+          node: callNode,
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
+          *fix(fixer) {
+            if (!parentNode.operator.startsWith('!')) {
+              yield fixer.insertTextBefore(parentNode, '!');
+            }
+            yield fixer.replaceTextRange(
+              getPropertyRange(node),
+              `.${isStartsWith ? 'start' : 'end'}sWith`,
+            );
+            yield fixer.replaceText(
+              callNode.arguments[0],
+              JSON.stringify(text),
+            );
+            yield fixer.removeRange([callNode.range[1], parentNode.range[1]]);
+          },
+        });
+      },
+
+      // foo.slice(0, 3) === 'bar'
+      // foo.slice(-3) === 'bar'
+      // foo.slice(-3, foo.length) === 'bar'
+      // foo.substring(0, 3) === 'bar'
+      // foo.substring(foo.length - 3) === 'bar'
+      // foo.substring(foo.length - 3, foo.length) === 'bar'
+      [String([
+        'CallExpression > MemberExpression.callee[property.name=slice][computed=false]',
+        'CallExpression > MemberExpression.callee[property.name=substring][computed=false]',
+      ])](node: TSESTree.MemberExpression): void {
+        const callNode = node.parent! as TSESTree.CallExpression;
+        const parentNode = callNode.parent!;
+        if (
+          !isEqualityComparison(parentNode) ||
+          parentNode.left !== callNode ||
+          !isStringType(node.object)
+        ) {
+          return;
+        }
+
+        const isEndsWith =
+          callNode.arguments.length === 1 ||
+          (callNode.arguments.length === 2 &&
+            isLengthExpression(callNode.arguments[1], node.object));
+        const isStartsWith =
+          !isEndsWith &&
+          callNode.arguments.length === 2 &&
+          isNumber(callNode.arguments[0], 0);
+        if (!isStartsWith && !isEndsWith) {
+          return;
+        }
+
+        const eqNode = parentNode;
+        const negativeIndexSupported = (node.property as any).name === 'slice';
+        context.report({
+          node: parentNode,
+          messageId: isStartsWith ? 'preferStartsWith' : 'preferEndsWith',
+          fix(fixer) {
+            // Don't fix if it can change the behavior.
+            if (
+              eqNode.operator.length === 2 &&
+              (eqNode.right.type !== 'Literal' ||
+                typeof eqNode.right.value !== 'string')
+            ) {
+              return null;
+            }
+            if (isStartsWith) {
+              if (!isLengthExpression(callNode.arguments[1], eqNode.right)) {
+                return null;
+              }
+            } else {
+              const posNode = callNode.arguments[0];
+              const posNodeIsAbsolutelyValid =
+                (posNode.type === 'BinaryExpression' &&
+                  posNode.operator === '-' &&
+                  isLengthExpression(posNode.left, node.object) &&
+                  isLengthExpression(posNode.right, eqNode.right)) ||
+                (negativeIndexSupported &&
+                  posNode.type === 'UnaryExpression' &&
+                  posNode.operator === '-' &&
+                  isLengthExpression(posNode.argument, eqNode.right));
+              if (!posNodeIsAbsolutelyValid) {
+                return null;
+              }
+            }
+
+            return fixWithRightOperand(
+              fixer,
+              parentNode,
+              isStartsWith ? 'start' : 'end',
+              parentNode.operator.startsWith('!'),
+            );
+          },
+        });
+      },
+
+      // /^bar/.test(foo)
+      // /bar$/.test(foo)
+      'CallExpression > MemberExpression.callee[property.name="test"][computed=false]'(
+        node: TSESTree.MemberExpression,
+      ): void {
+        const callNode = node.parent as TSESTree.CallExpression;
+        const parsed =
+          callNode.arguments.length === 1 ? parseRegExp(node.object) : null;
+        if (parsed == null) {
+          return;
+        }
+
+        const { isStartsWith, text } = parsed;
+        const messageId = isStartsWith ? 'preferStartsWith' : 'preferEndsWith';
+        const methodName = isStartsWith ? 'startsWith' : 'endsWith';
+        context.report({
+          node: callNode,
+          messageId,
+          *fix(fixer) {
+            const argNode = callNode.arguments[0];
+            const needsParen =
+              argNode.type !== 'Literal' &&
+              argNode.type !== 'TemplateLiteral' &&
+              argNode.type !== 'Identifier' &&
+              argNode.type !== 'MemberExpression' &&
+              argNode.type !== 'CallExpression';
+
+            yield fixer.removeRange([callNode.range[0], argNode.range[0]]);
+            if (needsParen) {
+              yield fixer.insertTextBefore(argNode, '(');
+              yield fixer.insertTextAfter(argNode, ')');
+            }
+            yield fixer.insertTextAfter(
+              argNode,
+              `.${methodName}(${JSON.stringify(text)}`,
+            );
+          },
+        });
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/tests/RuleTester.ts b/packages/eslint-plugin/tests/RuleTester.ts
index d485611be444..c51fa532a82a 100644
--- a/packages/eslint-plugin/tests/RuleTester.ts
+++ b/packages/eslint-plugin/tests/RuleTester.ts
@@ -22,7 +22,7 @@ interface InvalidTestCase<
   TOptions extends Readonly<any[]>
 > extends ValidTestCase<TOptions> {
   errors: TestCaseError<TMessageIds>[];
-  output?: string;
+  output?: string | null;
 }
 
 interface TestCaseError<TMessageIds extends string> {
diff --git a/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts b/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
new file mode 100644
index 000000000000..cc1e0063bd26
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/prefer-string-starts-ends-with.test.ts
@@ -0,0 +1,1046 @@
+import path from 'path';
+import rule from '../../src/rules/prefer-string-starts-ends-with';
+import { RuleTester } from '../RuleTester';
+
+const rootPath = path.join(process.cwd(), 'tests/fixtures/');
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    tsconfigRootDir: rootPath,
+    project: './tsconfig.json',
+  },
+});
+
+ruleTester.run('prefer-string-starts-ends-with', rule, {
+  valid: [
+    `
+      function f(s: string[]) {
+        s[0] === "a"
+      }
+    `,
+    `
+      function f(s: string) {
+        s[0] + "a"
+      }
+    `,
+    `
+      function f(s: string) {
+        s[1] === "a"
+      }
+    `,
+    `
+      function f(s: string | string[]) {
+        s[0] === "a"
+      }
+    `,
+    `
+      function f(s: any) {
+        s[0] === "a"
+      }
+    `,
+    `
+      function f<T>(s: T) {
+        s[0] === "a"
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s[s.length - 1] === "a"
+      }
+    `,
+    `
+      function f(s: string) {
+        s[s.length - 2] === "a"
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.charAt(0) === "a"
+      }
+    `,
+    `
+      function f(s: string) {
+        s.charAt(0) + "a"
+      }
+    `,
+    `
+      function f(s: string) {
+        s.charAt(1) === "a"
+      }
+    `,
+    `
+      function f(s: string) {
+        s.charAt() === "a"
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.charAt(s.length - 1) === "a"
+      }
+    `,
+    `
+      function f(a: string, b: string, c: string) {
+        (a + b).charAt((a + c).length - 1) === "a"
+      }
+    `,
+    `
+      function f(a: string, b: string, c: string) {
+        (a + b).charAt(c.length - 1) === "a"
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.indexOf(needle) === 0
+      }
+    `,
+    `
+      function f(s: string | string[]) {
+        s.indexOf(needle) === 0
+      }
+    `,
+    `
+      function f(s: string) {
+        s.indexOf(needle) === s.length - needle.length
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.lastIndexOf(needle) === s.length - needle.length
+      }
+    `,
+    `
+      function f(s: string) {
+        s.lastIndexOf(needle) === 0
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo/)
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/foo$/)
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo/) + 1
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/foo$/) + 1
+      }
+    `,
+    `
+      function f(s: { match(x: any): boolean }) {
+        s.match(/^foo/) !== null
+      }
+    `,
+    `
+      function f(s: { match(x: any): boolean }) {
+        s.match(/foo$/) !== null
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/foo/) !== null
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo$/) !== null
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo./) !== null
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(/^foo|bar/) !== null
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(new RegExp("")) !== null
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(pattern) !== null // cannot check '^'/'$'
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(new RegExp("^/!{[", "u")) !== null // has syntax error
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match() !== null
+      }
+    `,
+    `
+      function f(s: string) {
+        s.match(777) !== null
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.slice(0, needle.length) === needle
+      }
+    `,
+    `
+      function f(s: string[]) {
+        s.slice(-needle.length) === needle
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(1, 4) === "bar"
+      }
+    `,
+    `
+      function f(s: string) {
+        s.slice(-4, -1) === "bar"
+      }
+    `,
+    `
+      function f(s: string) {
+        pattern.test(s)
+      }
+    `,
+    `
+      function f(s: string) {
+        /^bar/.test()
+      }
+    `,
+    `
+      function f(x: { test(): void }, s: string) {
+        x.test(s)
+      }
+    `,
+  ],
+  invalid: [
+    // String indexing.
+    {
+      code: `
+        function f(s: string) {
+          s[0] === "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] !== "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] == "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] != "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] === "あ"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("あ")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[0] === "👍" // the length is 2.
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string, t: string) {
+          s[0] === t // the length of t is unknown.
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s[s.length - 1] === "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          (s)[0] === ("a")
+        }
+      `,
+      output: `
+        function f(s: string) {
+          (s).startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+
+    // String#charAt
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) === "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) !== "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) == "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) != "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) === "あ"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("あ")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(0) === "👍" // the length is 2.
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string, t: string) {
+          s.charAt(0) === t // the length of t is unknown.
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.charAt(s.length - 1) === "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          (s).charAt(0) === "a"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          (s).startsWith("a")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+
+    // String#indexOf
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) === 0
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) !== 0
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) == 0
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.indexOf(needle) != 0
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+
+    // String#lastIndexOf
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf("bar") === s.length - 3
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf("bar") !== s.length - 3
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf("bar") == s.length - 3
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf("bar") != s.length - 3
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf("bar") === s.length - "bar".length
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.lastIndexOf(needle) === s.length - needle.length
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+
+    // String#match
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) !== null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) != null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) !== null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) != null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) === null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/^bar/) == null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) === null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.match(/bar$/) == null
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        const pattern = /^bar/
+        function f(s: string) {
+          s.match(pattern) != null
+        }
+      `,
+      output: `
+        const pattern = /^bar/
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        const pattern = new RegExp("^bar")
+        function f(s: string) {
+          s.match(pattern) != null
+        }
+      `,
+      output: `
+        const pattern = new RegExp("^bar")
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        const pattern = /^"quoted"/
+        function f(s: string) {
+          s.match(pattern) != null
+        }
+      `,
+      output: `
+        const pattern = /^"quoted"/
+        function f(s: string) {
+          s.startsWith("\\"quoted\\"")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+
+    // String#slice
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) === "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) !== "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) == "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, 3) != "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, needle.length) === needle
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, length) === needle // the 'length' can be different to 'needle.length'
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(0, needle.length) == needle // hating implicit type conversion
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(-3) === "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(-3) !== "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          !s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(-needle.length) === needle
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(s.length - needle.length) === needle
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.slice(startIndex) === needle // 'startIndex' can be different
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.substring(0, 3) === "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.substring(-3) === "bar" // the code is probably mistake.
+        }
+      `,
+      output: null,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          s.substring(s.length - 3, s.length) === "bar"
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+
+    // RegExp#test
+    {
+      code: `
+        function f(s: string) {
+          /^bar/.test(s)
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          /bar$/.test(s)
+        }
+      `,
+      output: `
+        function f(s: string) {
+          s.endsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferEndsWith' }],
+    },
+    {
+      code: `
+        const pattern = /^bar/
+        function f(s: string) {
+          pattern.test(s)
+        }
+      `,
+      output: `
+        const pattern = /^bar/
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        const pattern = new RegExp("^bar")
+        function f(s: string) {
+          pattern.test(s)
+        }
+      `,
+      output: `
+        const pattern = new RegExp("^bar")
+        function f(s: string) {
+          s.startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        const pattern = /^"quoted"/
+        function f(s: string) {
+          pattern.test(s)
+        }
+      `,
+      output: `
+        const pattern = /^"quoted"/
+        function f(s: string) {
+          s.startsWith("\\"quoted\\"")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f(s: string) {
+          /^bar/.test(a + b)
+        }
+      `,
+      output: `
+        function f(s: string) {
+          (a + b).startsWith("bar")
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+
+    // Test for variation of string types.
+    {
+      code: `
+        function f(s: "a" | "b") {
+          s.indexOf(needle) === 0
+        }
+      `,
+      output: `
+        function f(s: "a" | "b") {
+          s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        function f<T extends "a" | "b">(s: T) {
+          s.indexOf(needle) === 0
+        }
+      `,
+      output: `
+        function f<T extends "a" | "b">(s: T) {
+          s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+    {
+      code: `
+        type SafeString = string & {__HTML_ESCAPED__: void}
+        function f(s: SafeString) {
+          s.indexOf(needle) === 0
+        }
+      `,
+      output: `
+        type SafeString = string & {__HTML_ESCAPED__: void}
+        function f(s: SafeString) {
+          s.startsWith(needle)
+        }
+      `,
+      errors: [{ messageId: 'preferStartsWith' }],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin/typings/ts-eslint.d.ts b/packages/eslint-plugin/typings/ts-eslint.d.ts
index d6bd1eef8a7c..34705d73e34d 100644
--- a/packages/eslint-plugin/typings/ts-eslint.d.ts
+++ b/packages/eslint-plugin/typings/ts-eslint.d.ts
@@ -299,7 +299,7 @@ declare module 'ts-eslint' {
 
   type ReportFixFunction = (
     fixer: RuleFixer,
-  ) => null | RuleFix | Iterable<RuleFix>;
+  ) => null | RuleFix | RuleFix[] | IterableIterator<RuleFix>;
 
   interface ReportDescriptor<TMessageIds extends string> {
     /**
@@ -690,6 +690,7 @@ declare module 'ts-eslint' {
     ReportFixFunction,
     RuleContext,
     RuleFix,
+    RuleFixer,
     RuleFunction,
     RuleListener,
     RuleMetaData,

From 116ca757b976300b49af08b97bcce59c1961c227 Mon Sep 17 00:00:00 2001
From: Denys Kniazevych <webschik@gmail.com>
Date: Thu, 11 Apr 2019 03:43:49 +0200
Subject: [PATCH 12/17] feat(eslint-plugin): support type assertions in
 no-extra-parens rule (#311)

---
 .../docs/rules/no-extra-parens.md             |  22 ++
 .../src/rules/no-extra-parens.ts              |  33 +++
 .../tests/rules/no-extra-parens.test.ts       | 266 ++++++++++++++++++
 .../eslint-plugin/typings/eslint-rules.d.ts   |  23 ++
 packages/eslint-plugin/typings/ts-eslint.d.ts |   6 +-
 .../src/ts-estree/ts-estree.ts                |   3 +-
 6 files changed, 351 insertions(+), 2 deletions(-)
 create mode 100644 packages/eslint-plugin/docs/rules/no-extra-parens.md
 create mode 100644 packages/eslint-plugin/src/rules/no-extra-parens.ts
 create mode 100644 packages/eslint-plugin/tests/rules/no-extra-parens.test.ts

diff --git a/packages/eslint-plugin/docs/rules/no-extra-parens.md b/packages/eslint-plugin/docs/rules/no-extra-parens.md
new file mode 100644
index 000000000000..d7942ec1b169
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/no-extra-parens.md
@@ -0,0 +1,22 @@
+# disallow unnecessary parentheses (no-extra-parens)
+
+This rule restricts the use of parentheses to only where they are necessary.
+
+## Rule Details
+
+This rule extends the base [eslint/no-extra-parens](https://eslint.org/docs/rules/no-extra-parens) rule.
+It supports all options and features of the base rule plus TS type assertions.
+
+## How to use
+
+```cjson
+{
+    // note you must disable the base rule as it can report incorrect errors
+    "no-extra-parens": "off",
+    "@typescript-eslint/no-extra-parens": ["error"]
+}
+```
+
+## Options
+
+See [eslint/no-extra-parens options](https://eslint.org/docs/rules/no-extra-parens#options).
diff --git a/packages/eslint-plugin/src/rules/no-extra-parens.ts b/packages/eslint-plugin/src/rules/no-extra-parens.ts
new file mode 100644
index 000000000000..3ad963974c2f
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/no-extra-parens.ts
@@ -0,0 +1,33 @@
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import baseRule from 'eslint/lib/rules/no-extra-parens';
+import * as util from '../util';
+
+type Options = util.InferOptionsTypeFromRule<typeof baseRule>;
+type MessageIds = util.InferMessageIdsTypeFromRule<typeof baseRule>;
+
+export default util.createRule<Options, MessageIds>({
+  name: 'no-extra-parens',
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'disallow unnecessary parentheses',
+      category: 'Possible Errors',
+      recommended: false,
+    },
+    fixable: 'code',
+    schema: baseRule.meta.schema,
+    messages: baseRule.meta.messages,
+  },
+  defaultOptions: ['all'],
+  create(context) {
+    const rules = baseRule.create(context);
+
+    return Object.assign({}, rules, {
+      MemberExpression(node: TSESTree.MemberExpression) {
+        if (node.object.type !== AST_NODE_TYPES.TSAsExpression) {
+          return rules.MemberExpression(node);
+        }
+      },
+    });
+  },
+});
diff --git a/packages/eslint-plugin/tests/rules/no-extra-parens.test.ts b/packages/eslint-plugin/tests/rules/no-extra-parens.test.ts
new file mode 100644
index 000000000000..154179c192c6
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/no-extra-parens.test.ts
@@ -0,0 +1,266 @@
+import rule from '../../src/rules/no-extra-parens';
+import { RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('no-extra-parens', rule, {
+  valid: [
+    {
+      code: `
+        (0).toString();
+        (function(){}) ? a() : b();        
+        (/^a$/).test(x);       
+        for (a of (b, c));        
+        for (a of b);     
+        for (a in b, c);  
+        for (a in b);
+      `,
+    },
+    {
+      code: `t.true((me.get as SinonStub).calledWithExactly('/foo', other));`,
+    },
+    {
+      code: `while ((foo = bar())) {}`,
+      options: ['all', { conditionalAssign: false }],
+    },
+    {
+      code: `if ((foo = bar())) {}`,
+      options: ['all', { conditionalAssign: false }],
+    },
+    {
+      code: `do; while ((foo = bar()))`,
+      options: ['all', { conditionalAssign: false }],
+    },
+    {
+      code: `for (;(a = b););`,
+      options: ['all', { conditionalAssign: false }],
+    },
+    {
+      code: `
+        function a(b) {
+          return (b = 1);
+        }
+      `,
+      options: ['all', { returnAssign: false }],
+    },
+    {
+      code: `
+        function a(b) {
+          return b ? (c = d) : (c = e);
+        }
+      `,
+      options: ['all', { returnAssign: false }],
+    },
+    {
+      code: `b => (b = 1);`,
+      options: ['all', { returnAssign: false }],
+    },
+    {
+      code: `b => b ? (c = d) : (c = e);`,
+      options: ['all', { returnAssign: false }],
+    },
+    {
+      code: `x = a || (b && c);`,
+      options: ['all', { nestedBinaryExpressions: false }],
+    },
+    {
+      code: `x = a + (b * c);`,
+      options: ['all', { nestedBinaryExpressions: false }],
+    },
+    {
+      code: `x = (a * b) / c;`,
+      options: ['all', { nestedBinaryExpressions: false }],
+    },
+    {
+      code: `
+        const Component = (<div />)
+        const Component = (
+            <div
+                prop={true}
+            />
+        )
+      `,
+      options: ['all', { ignoreJSX: 'all' }],
+    },
+    {
+      code: `
+        const Component = (
+            <div>
+                <p />
+            </div>
+        )
+        const Component = (
+            <div
+                prop={true}
+            />
+        )
+      `,
+      options: ['all', { ignoreJSX: 'multi-line' }],
+    },
+    {
+      code: `
+        const Component = (<div />)
+        const Component = (<div><p /></div>)
+      `,
+      options: ['all', { ignoreJSX: 'single-line' }],
+    },
+    {
+      code: `
+        const b = a => 1 ? 2 : 3;
+        const d = c => (1 ? 2 : 3);
+      `,
+      options: ['all', { enforceForArrowConditionals: false }],
+    },
+    {
+      code: `
+        (0).toString();
+        (Object.prototype.toString.call());
+        ({}.toString.call());
+        (function(){} ? a() : b());
+        (/^a$/).test(x);
+        a = (b * c);
+        (a * b) + c;
+        typeof (a);
+      `,
+      options: ['functions'],
+    },
+  ],
+
+  invalid: [
+    {
+      code: `a = (b * c);`,
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 5,
+        },
+      ],
+    },
+    {
+      code: `(a * b) + c;`,
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 1,
+        },
+      ],
+    },
+    {
+      code: `for (a in (b, c));`,
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 11,
+        },
+      ],
+    },
+    {
+      code: `for (a in (b));`,
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 11,
+        },
+      ],
+    },
+    {
+      code: `for (a of (b));`,
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 11,
+        },
+      ],
+    },
+    {
+      code: `typeof (a);`,
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 8,
+        },
+      ],
+    },
+    {
+      code: `
+        const Component = (<div />)
+        const Component = (<div><p /></div>)
+      `,
+      options: ['all', { ignoreJSX: 'multi-line' }],
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 2,
+          column: 27,
+        },
+        {
+          messageId: 'unexpected',
+          line: 3,
+          column: 27,
+        },
+      ],
+    },
+    {
+      code: `
+        const Component = (
+            <div>
+                <p />
+            </div>
+        )
+        const Component = (
+            <div
+                prop={true}
+            />
+        )
+      `,
+      options: ['all', { ignoreJSX: 'single-line' }],
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 2,
+          column: 27,
+        },
+        {
+          messageId: 'unexpected',
+          line: 7,
+          column: 27,
+        },
+      ],
+    },
+    {
+      code: `((function foo() {}))();`,
+      options: ['functions'],
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 2,
+        },
+      ],
+    },
+    {
+      code: `var y = (function () {return 1;});`,
+      options: ['functions'],
+      errors: [
+        {
+          messageId: 'unexpected',
+          line: 1,
+          column: 9,
+        },
+      ],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin/typings/eslint-rules.d.ts b/packages/eslint-plugin/typings/eslint-rules.d.ts
index b4094c05474f..aca4c8d8638c 100644
--- a/packages/eslint-plugin/typings/eslint-rules.d.ts
+++ b/packages/eslint-plugin/typings/eslint-rules.d.ts
@@ -330,3 +330,26 @@ declare module 'eslint/lib/rules/no-useless-constructor' {
   >;
   export = rule;
 }
+
+declare module 'eslint/lib/rules/no-extra-parens' {
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
+  import RuleModule from 'ts-eslint';
+
+  const rule: RuleModule<
+    'unexpected',
+    (
+      | 'all'
+      | 'functions'
+      | {
+          conditionalAssign?: boolean;
+          returnAssign?: boolean;
+          nestedBinaryExpressions?: boolean;
+          ignoreJSX?: 'none' | 'all' | 'multi-line' | 'single-line';
+          enforceForArrowConditionals?: boolean;
+        })[],
+    {
+      MemberExpression(node: TSESTree.MemberExpression): void;
+    }
+  >;
+  export = rule;
+}
diff --git a/packages/eslint-plugin/typings/ts-eslint.d.ts b/packages/eslint-plugin/typings/ts-eslint.d.ts
index 34705d73e34d..ce6e6c577c28 100644
--- a/packages/eslint-plugin/typings/ts-eslint.d.ts
+++ b/packages/eslint-plugin/typings/ts-eslint.d.ts
@@ -209,7 +209,11 @@ declare module 'ts-eslint' {
     /**
      * The general category the rule falls within
      */
-    category: 'Best Practices' | 'Stylistic Issues' | 'Variables';
+    category:
+      | 'Best Practices'
+      | 'Stylistic Issues'
+      | 'Variables'
+      | 'Possible Errors';
     /**
      * Concise description of the rule
      */
diff --git a/packages/typescript-estree/src/ts-estree/ts-estree.ts b/packages/typescript-estree/src/ts-estree/ts-estree.ts
index 6c0808b95624..52f1214f1d34 100644
--- a/packages/typescript-estree/src/ts-estree/ts-estree.ts
+++ b/packages/typescript-estree/src/ts-estree/ts-estree.ts
@@ -323,7 +323,8 @@ export type LeftHandSideExpression =
   | MemberExpression
   | PrimaryExpression
   | TaggedTemplateExpression
-  | TSNonNullExpression;
+  | TSNonNullExpression
+  | TSAsExpression;
 export type LiteralExpression = BigIntLiteral | Literal | TemplateLiteral;
 export type Modifier =
   | TSAbstractKeyword

From ba0d52461a7289e0cb61d591b881c61beccf5dec Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Wed, 10 Apr 2019 18:55:57 -0700
Subject: [PATCH 13/17] docs(eslint-plugin): Correct link to no-unused-vars
 (#418)

Fixes #396
---
 packages/eslint-plugin/ROADMAP.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/packages/eslint-plugin/ROADMAP.md b/packages/eslint-plugin/ROADMAP.md
index 9622f367f577..e5fc5ebe2594 100644
--- a/packages/eslint-plugin/ROADMAP.md
+++ b/packages/eslint-plugin/ROADMAP.md
@@ -82,7 +82,7 @@
 | [`no-unsafe-any`]                    | 🛑  | N/A                                                                   |
 | [`no-unsafe-finally`]                | 🌟  | [`no-unsafe-finally`][no-unsafe-finally]                              |
 | [`no-unused-expression`]             | 🌟  | [`no-unused-expression`][no-unused-expressions]                       |
-| [`no-unused-variable`]               | 🌓  | [`no-unused-vars`][no-unused-vars] <sup>[2]</sup>                     |
+| [`no-unused-variable`]               | 🌓  | [`@typescript-eslint/no-unused-vars`]                                 |
 | [`no-use-before-declare`]            | ✅  | [`@typescript-eslint/no-use-before-define`]                           |
 | [`no-var-keyword`]                   | 🌟  | [`no-var`][no-var]                                                    |
 | [`no-void-expression`]               | 🌟  | [`no-void`][no-void]                                                  |
@@ -100,7 +100,6 @@
 | [`use-isnan`]                        | 🌟  | [`use-isnan`][use-isnan]                                              |
 
 <sup>[1]</sup> The ESLint rule also supports silencing with an extra set of parens (`if ((foo = bar)) {}`)<br>
-<sup>[2]</sup> Missing private class member support. [`@typescript-eslint/no-unused-vars`] adds support for some TS-specific features.
 
 ### Maintainability
 
@@ -508,7 +507,6 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint-
 [no-fallthrough]: https://eslint.org/docs/rules/no-fallthrough
 [no-unsafe-finally]: https://eslint.org/docs/rules/no-unsafe-finally
 [no-unused-expressions]: https://eslint.org/docs/rules/no-unused-expressions
-[no-unused-vars]: https://eslint.org/docs/rules/no-unused-vars
 [no-var]: https://eslint.org/docs/rules/no-var
 [no-void]: https://eslint.org/docs/rules/no-void
 [prefer-object-spread]: https://eslint.org/docs/rules/prefer-object-spread

From eee6d49bbde8d7ff512a009d3dde10c430a6f6c5 Mon Sep 17 00:00:00 2001
From: Denys Kniazevych <webschik@gmail.com>
Date: Fri, 12 Apr 2019 00:25:03 +0200
Subject: [PATCH 14/17] fix(eslint-plugin): support BigInt in
 restrict-plus-operands rule (#344)

Fixes #309
---
 .../src/rules/restrict-plus-operands.ts       |  6 ++++-
 .../tests/fixtures/tsconfig.json              |  2 +-
 .../rules/restrict-plus-operands.test.ts      | 22 +++++++++++++++++++
 3 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
index 6b63f88a4f74..62b1b1f79ceb 100644
--- a/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
+++ b/packages/eslint-plugin/src/rules/restrict-plus-operands.ts
@@ -54,7 +54,11 @@ export default util.createRule({
 
       const stringType = typeChecker.typeToString(type);
 
-      if (stringType === 'number' || stringType === 'string') {
+      if (
+        stringType === 'number' ||
+        stringType === 'string' ||
+        stringType === 'bigint'
+      ) {
         return stringType;
       }
       return 'invalid';
diff --git a/packages/eslint-plugin/tests/fixtures/tsconfig.json b/packages/eslint-plugin/tests/fixtures/tsconfig.json
index 8702b63472ba..bedda0e3decc 100644
--- a/packages/eslint-plugin/tests/fixtures/tsconfig.json
+++ b/packages/eslint-plugin/tests/fixtures/tsconfig.json
@@ -4,6 +4,6 @@
     "module": "commonjs",
     "strict": true,
     "esModuleInterop": true,
-    "lib": ["es2015", "es2017"]
+    "lib": ["es2015", "es2017", "esnext"]
   }
 }
diff --git a/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts b/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
index 4cff2c7c5c12..ae4fe89af156 100644
--- a/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
@@ -23,6 +23,8 @@ ruleTester.run('restrict-plus-operands', rule, {
     `var foo = parseInt("5.5", 10) + 10;`,
     `var foo = parseFloat("5.5", 10) + 10;`,
     `var foo = 1n + 1n;`,
+    `var foo = BigInt(1) + 1n`,
+    `var foo = 1n; foo + 2n`,
     `
 function test () : number { return 2; }
 var foo = test("5.5", 10) + 10;
@@ -283,5 +285,25 @@ var foo = pair + pair;
         },
       ],
     },
+    {
+      code: `var foo = 1n; foo + 1`,
+      errors: [
+        {
+          messageId: 'notBigInts',
+          line: 1,
+          column: 15,
+        },
+      ],
+    },
+    {
+      code: `var foo = 1; foo + 1n`,
+      errors: [
+        {
+          messageId: 'notBigInts',
+          line: 1,
+          column: 14,
+        },
+      ],
+    },
   ],
 });

From 6c50a993a9737092a1e060ec2a144d121b03e31c Mon Sep 17 00:00:00 2001
From: Witt <lambdas.dev@gmail.com>
Date: Mon, 15 Apr 2019 23:43:43 +0800
Subject: [PATCH 15/17] docs(eslint-plugin): ban-types: fix example syntax
 (#430)

---
 packages/eslint-plugin/docs/rules/ban-types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/docs/rules/ban-types.md b/packages/eslint-plugin/docs/rules/ban-types.md
index 5ab5e6e96e76..dc88b913f2ca 100644
--- a/packages/eslint-plugin/docs/rules/ban-types.md
+++ b/packages/eslint-plugin/docs/rules/ban-types.md
@@ -46,7 +46,7 @@ class Foo<F = string> extends Bar<string> implements Baz<string> {
                 "fixWith": "string"
             }
         }
-    }
+    }]
 }
 ```
 

From 95593230e6463eee251983204a17cf51a93e8e1e Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Sat, 20 Apr 2019 13:23:37 -0700
Subject: [PATCH 16/17] chore: simplify git hooks (#445)

---
 .huskyrc            |  5 ++---
 azure-pipelines.yml |  2 +-
 package.json        | 16 +++++++++-------
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/.huskyrc b/.huskyrc
index a3f3f7002ed4..687c2614bf8a 100644
--- a/.huskyrc
+++ b/.huskyrc
@@ -1,8 +1,7 @@
 {
   "hooks": {
-    "pre-commit": [
-        "yarn test && lint-staged"
-    ],
+    "pre-commit": "yarn pre-commit",
+    "pre-push": "yarn pre-push",
     "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
   }
 }
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index eee318c9eb88..911aa93bb3c7 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -24,7 +24,7 @@ jobs:
         displayName: 'Typecheck all packages'
 
       - script: |
-          yarn check-format
+          yarn format-check
         displayName: 'Check code formatting'
 
       - script: |
diff --git a/package.json b/package.json
index 87f47a22a52c..f0f5a45beef1 100644
--- a/package.json
+++ b/package.json
@@ -17,19 +17,21 @@
     "url": "https://github.com/typescript-eslint/typescript-eslint/issues"
   },
   "scripts": {
-    "postinstall": "lerna bootstrap && yarn build && lerna link",
-    "test": "lerna run test --parallel",
     "build": "lerna run build",
     "clean": "lerna clean && lerna run clean",
-    "typecheck": "lerna run typecheck",
-    "lint": "eslint . --ext .js,.ts",
-    "lint-fix": "eslint . --ext .js,.ts --fix",
     "cz": "git-cz",
-    "check-format": "prettier --list-different \"./**/*.{ts,js,json,md}\"",
+    "generate-contributors": "yarn ts-node ./tools/generate-contributors.ts && yarn all-contributors generate",
     "format": "prettier --write \"./**/*.{ts,js,json,md}\"",
+    "format-check": "prettier --list-different \"./**/*.{ts,js,json,md}\"",
     "integration-tests": "docker-compose -f tests/integration/docker-compose.yml up",
     "kill-integration-test-containers": "docker-compose -f tests/integration/docker-compose.yml down -v --rmi local",
-    "generate-contributors": "yarn ts-node ./tools/generate-contributors.ts && yarn all-contributors generate"
+    "lint": "eslint . --ext .js,.ts",
+    "lint-fix": "eslint . --ext .js,.ts --fix",
+    "pre-commit": "yarn lint-staged",
+    "pre-push": "yarn lint && yarn typecheck && yarn format-check",
+    "postinstall": "lerna bootstrap && yarn build && lerna link",
+    "test": "lerna run test --parallel",
+    "typecheck": "lerna run typecheck"
   },
   "config": {
     "commitizen": {

From 24a0d1e2d5f85b1115dffe4ee5cadb27e7f02869 Mon Sep 17 00:00:00 2001
From: James Henry <james@henry.sc>
Date: Sat, 20 Apr 2019 16:26:57 -0400
Subject: [PATCH 17/17] chore: publish v1.7.0

---
 CHANGELOG.md                               | 18 ++++++++++++++++++
 lerna.json                                 |  2 +-
 packages/eslint-plugin-tslint/CHANGELOG.md |  4 ++++
 packages/eslint-plugin-tslint/package.json |  4 ++--
 packages/eslint-plugin/CHANGELOG.md        | 18 ++++++++++++++++++
 packages/eslint-plugin/package.json        |  6 +++---
 packages/parser/CHANGELOG.md               |  4 ++++
 packages/parser/package.json               |  6 +++---
 packages/shared-fixtures/CHANGELOG.md      |  8 ++++++++
 packages/shared-fixtures/package.json      |  2 +-
 packages/typescript-estree/CHANGELOG.md    |  6 ++++++
 packages/typescript-estree/package.json    |  4 ++--
 12 files changed, 70 insertions(+), 12 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7eb1d41a2848..f21399e8351d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.7.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.6.0...v1.7.0) (2019-04-20)
+
+### Bug Fixes
+
+- **eslint-plugin:** indent: fix false positive on type parameters ([#385](https://github.com/typescript-eslint/typescript-eslint/issues/385)) ([d476f15](https://github.com/typescript-eslint/typescript-eslint/commit/d476f15))
+- **eslint-plugin:** no-object-literal-type-assertion: fix `as const` is reported ([#390](https://github.com/typescript-eslint/typescript-eslint/issues/390)) ([2521b85](https://github.com/typescript-eslint/typescript-eslint/commit/2521b85))
+- **eslint-plugin:** support BigInt in restrict-plus-operands rule ([#344](https://github.com/typescript-eslint/typescript-eslint/issues/344)) ([eee6d49](https://github.com/typescript-eslint/typescript-eslint/commit/eee6d49)), closes [#309](https://github.com/typescript-eslint/typescript-eslint/issues/309)
+
+### Features
+
+- **eslint-plugin:** [member-accessibility] add more options ([#322](https://github.com/typescript-eslint/typescript-eslint/issues/322)) ([4b3d820](https://github.com/typescript-eslint/typescript-eslint/commit/4b3d820))
+- **eslint-plugin:** add prefer-for-of rule ([#338](https://github.com/typescript-eslint/typescript-eslint/issues/338)) ([3e26ab6](https://github.com/typescript-eslint/typescript-eslint/commit/3e26ab6))
+- **eslint-plugin:** add prefer-includes rule ([#294](https://github.com/typescript-eslint/typescript-eslint/issues/294)) ([01c4dae](https://github.com/typescript-eslint/typescript-eslint/commit/01c4dae)), closes [#284](https://github.com/typescript-eslint/typescript-eslint/issues/284)
+- **eslint-plugin:** add prefer-string-starts-ends-with rule ([#289](https://github.com/typescript-eslint/typescript-eslint/issues/289)) ([5592a2c](https://github.com/typescript-eslint/typescript-eslint/commit/5592a2c)), closes [#285](https://github.com/typescript-eslint/typescript-eslint/issues/285)
+- **eslint-plugin:** added new rule await-promise ([#192](https://github.com/typescript-eslint/typescript-eslint/issues/192)) ([5311342](https://github.com/typescript-eslint/typescript-eslint/commit/5311342))
+- **eslint-plugin:** added new rule unbound-method ([#204](https://github.com/typescript-eslint/typescript-eslint/issues/204)) ([6718906](https://github.com/typescript-eslint/typescript-eslint/commit/6718906))
+- **eslint-plugin:** support type assertions in no-extra-parens rule ([#311](https://github.com/typescript-eslint/typescript-eslint/issues/311)) ([116ca75](https://github.com/typescript-eslint/typescript-eslint/commit/116ca75))
+
 # [1.6.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.5.0...v1.6.0) (2019-04-03)
 
 ### Bug Fixes
diff --git a/lerna.json b/lerna.json
index f7243f760b61..9bcec435d8f5 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "1.6.0",
+  "version": "1.7.0",
   "npmClient": "yarn",
   "useWorkspaces": true,
   "stream": true
diff --git a/packages/eslint-plugin-tslint/CHANGELOG.md b/packages/eslint-plugin-tslint/CHANGELOG.md
index a932eb1dc8c6..6cdd0814015f 100644
--- a/packages/eslint-plugin-tslint/CHANGELOG.md
+++ b/packages/eslint-plugin-tslint/CHANGELOG.md
@@ -3,6 +3,10 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.7.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.6.0...v1.7.0) (2019-04-20)
+
+**Note:** Version bump only for package @typescript-eslint/eslint-plugin-tslint
+
 # [1.6.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.5.0...v1.6.0) (2019-04-03)
 
 **Note:** Version bump only for package @typescript-eslint/eslint-plugin-tslint
diff --git a/packages/eslint-plugin-tslint/package.json b/packages/eslint-plugin-tslint/package.json
index c8279102b38d..5e5bab756a9d 100644
--- a/packages/eslint-plugin-tslint/package.json
+++ b/packages/eslint-plugin-tslint/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin-tslint",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "main": "dist/index.js",
   "typings": "src/index.ts",
   "description": "TSLint wrapper plugin for ESLint",
@@ -35,6 +35,6 @@
   "devDependencies": {
     "@types/eslint": "^4.16.3",
     "@types/lodash.memoize": "^4.1.4",
-    "@typescript-eslint/parser": "1.6.0"
+    "@typescript-eslint/parser": "1.7.0"
   }
 }
diff --git a/packages/eslint-plugin/CHANGELOG.md b/packages/eslint-plugin/CHANGELOG.md
index 628a911c3343..97c3b7e7b7d7 100644
--- a/packages/eslint-plugin/CHANGELOG.md
+++ b/packages/eslint-plugin/CHANGELOG.md
@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.7.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.6.0...v1.7.0) (2019-04-20)
+
+### Bug Fixes
+
+- **eslint-plugin:** indent: fix false positive on type parameters ([#385](https://github.com/typescript-eslint/typescript-eslint/issues/385)) ([d476f15](https://github.com/typescript-eslint/typescript-eslint/commit/d476f15))
+- **eslint-plugin:** no-object-literal-type-assertion: fix `as const` is reported ([#390](https://github.com/typescript-eslint/typescript-eslint/issues/390)) ([2521b85](https://github.com/typescript-eslint/typescript-eslint/commit/2521b85))
+- **eslint-plugin:** support BigInt in restrict-plus-operands rule ([#344](https://github.com/typescript-eslint/typescript-eslint/issues/344)) ([eee6d49](https://github.com/typescript-eslint/typescript-eslint/commit/eee6d49)), closes [#309](https://github.com/typescript-eslint/typescript-eslint/issues/309)
+
+### Features
+
+- **eslint-plugin:** [member-accessibility] add more options ([#322](https://github.com/typescript-eslint/typescript-eslint/issues/322)) ([4b3d820](https://github.com/typescript-eslint/typescript-eslint/commit/4b3d820))
+- **eslint-plugin:** add prefer-for-of rule ([#338](https://github.com/typescript-eslint/typescript-eslint/issues/338)) ([3e26ab6](https://github.com/typescript-eslint/typescript-eslint/commit/3e26ab6))
+- **eslint-plugin:** add prefer-includes rule ([#294](https://github.com/typescript-eslint/typescript-eslint/issues/294)) ([01c4dae](https://github.com/typescript-eslint/typescript-eslint/commit/01c4dae)), closes [#284](https://github.com/typescript-eslint/typescript-eslint/issues/284)
+- **eslint-plugin:** add prefer-string-starts-ends-with rule ([#289](https://github.com/typescript-eslint/typescript-eslint/issues/289)) ([5592a2c](https://github.com/typescript-eslint/typescript-eslint/commit/5592a2c)), closes [#285](https://github.com/typescript-eslint/typescript-eslint/issues/285)
+- **eslint-plugin:** added new rule await-promise ([#192](https://github.com/typescript-eslint/typescript-eslint/issues/192)) ([5311342](https://github.com/typescript-eslint/typescript-eslint/commit/5311342))
+- **eslint-plugin:** added new rule unbound-method ([#204](https://github.com/typescript-eslint/typescript-eslint/issues/204)) ([6718906](https://github.com/typescript-eslint/typescript-eslint/commit/6718906))
+- **eslint-plugin:** support type assertions in no-extra-parens rule ([#311](https://github.com/typescript-eslint/typescript-eslint/issues/311)) ([116ca75](https://github.com/typescript-eslint/typescript-eslint/commit/116ca75))
+
 # [1.6.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.5.0...v1.6.0) (2019-04-03)
 
 ### Bug Fixes
diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json
index 6a292d723bd2..014c8c6c7547 100644
--- a/packages/eslint-plugin/package.json
+++ b/packages/eslint-plugin/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "TypeScript plugin for ESLint",
   "keywords": [
     "eslint",
@@ -35,8 +35,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/parser": "1.6.0",
-    "@typescript-eslint/typescript-estree": "1.6.0",
+    "@typescript-eslint/parser": "1.7.0",
+    "@typescript-eslint/typescript-estree": "1.7.0",
     "eslint-utils": "^1.3.1",
     "regexpp": "^2.0.1",
     "requireindex": "^1.2.0",
diff --git a/packages/parser/CHANGELOG.md b/packages/parser/CHANGELOG.md
index 9c7424ad92ef..6fc65257e157 100644
--- a/packages/parser/CHANGELOG.md
+++ b/packages/parser/CHANGELOG.md
@@ -3,6 +3,10 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.7.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.6.0...v1.7.0) (2019-04-20)
+
+**Note:** Version bump only for package @typescript-eslint/parser
+
 # [1.6.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.5.0...v1.6.0) (2019-04-03)
 
 ### Bug Fixes
diff --git a/packages/parser/package.json b/packages/parser/package.json
index b2fac500f33e..d1ca3e73628e 100644
--- a/packages/parser/package.json
+++ b/packages/parser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/parser",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "An ESLint custom parser which leverages TypeScript ESTree",
   "main": "dist/parser.js",
   "files": [
@@ -37,13 +37,13 @@
     "typescript": "*"
   },
   "dependencies": {
-    "@typescript-eslint/typescript-estree": "1.6.0",
+    "@typescript-eslint/typescript-estree": "1.7.0",
     "eslint-scope": "^4.0.0",
     "eslint-visitor-keys": "^1.0.0"
   },
   "devDependencies": {
     "@types/eslint": "^4.16.5",
     "@types/eslint-visitor-keys": "^1.0.0",
-    "@typescript-eslint/shared-fixtures": "1.6.0"
+    "@typescript-eslint/shared-fixtures": "1.7.0"
   }
 }
diff --git a/packages/shared-fixtures/CHANGELOG.md b/packages/shared-fixtures/CHANGELOG.md
index 93be6b449718..32bdb51cae36 100644
--- a/packages/shared-fixtures/CHANGELOG.md
+++ b/packages/shared-fixtures/CHANGELOG.md
@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.7.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.6.0...v1.7.0) (2019-04-20)
+
+**Note:** Version bump only for package @typescript-eslint/shared-fixtures
+
+
+
+
+
 # [1.6.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.5.0...v1.6.0) (2019-04-03)
 
 
diff --git a/packages/shared-fixtures/package.json b/packages/shared-fixtures/package.json
index 049c984ba45f..7ea47d8b5a46 100644
--- a/packages/shared-fixtures/package.json
+++ b/packages/shared-fixtures/package.json
@@ -1,5 +1,5 @@
 {
   "name": "@typescript-eslint/shared-fixtures",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "private": true
 }
diff --git a/packages/typescript-estree/CHANGELOG.md b/packages/typescript-estree/CHANGELOG.md
index 45dd075c5ff2..936720f36d5d 100644
--- a/packages/typescript-estree/CHANGELOG.md
+++ b/packages/typescript-estree/CHANGELOG.md
@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.7.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.6.0...v1.7.0) (2019-04-20)
+
+### Features
+
+- **eslint-plugin:** support type assertions in no-extra-parens rule ([#311](https://github.com/typescript-eslint/typescript-eslint/issues/311)) ([116ca75](https://github.com/typescript-eslint/typescript-eslint/commit/116ca75))
+
 # [1.6.0](https://github.com/typescript-eslint/typescript-eslint/compare/v1.5.0...v1.6.0) (2019-04-03)
 
 ### Bug Fixes
diff --git a/packages/typescript-estree/package.json b/packages/typescript-estree/package.json
index 10bc1779c11e..c5d6fe2d0ef1 100644
--- a/packages/typescript-estree/package.json
+++ b/packages/typescript-estree/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
@@ -44,6 +44,6 @@
   },
   "devDependencies": {
     "@babel/types": "^7.3.2",
-    "@typescript-eslint/shared-fixtures": "1.6.0"
+    "@typescript-eslint/shared-fixtures": "1.7.0"
   }
 }