From b2dbd890a5bef81aa6978d68c166457838ee04a1 Mon Sep 17 00:00:00 2001
From: Gareth Jones <Jones258@Gmail.com>
Date: Mon, 23 Mar 2020 18:10:17 +1300
Subject: [PATCH 01/36] feat(eslint-plugin): add `class-literal-property-style`
 rule (#1582)

---
 packages/eslint-plugin/README.md              |   1 +
 .../rules/class-literal-property-style.md     |  96 +++++
 packages/eslint-plugin/src/configs/all.json   |   1 +
 .../src/rules/class-literal-property-style.ts | 136 +++++++
 packages/eslint-plugin/src/rules/index.ts     |   2 +
 .../class-literal-property-style.test.ts      | 378 ++++++++++++++++++
 6 files changed, 614 insertions(+)
 create mode 100644 packages/eslint-plugin/docs/rules/class-literal-property-style.md
 create mode 100644 packages/eslint-plugin/src/rules/class-literal-property-style.ts
 create mode 100644 packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts

diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
index b7927757924..fa049b2cfb2 100644
--- a/packages/eslint-plugin/README.md
+++ b/packages/eslint-plugin/README.md
@@ -99,6 +99,7 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int
 | [`@typescript-eslint/await-thenable`](./docs/rules/await-thenable.md)                                                 | Disallows awaiting a value that is not a Thenable                                                                       | :heavy_check_mark: |          | :thought_balloon: |
 | [`@typescript-eslint/ban-ts-comment`](./docs/rules/ban-ts-comment.md)                                                 | Bans `// @ts-<directive>` comments from being used                                                                      |                    |          |                   |
 | [`@typescript-eslint/ban-types`](./docs/rules/ban-types.md)                                                           | Bans specific types from being used                                                                                     | :heavy_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/class-literal-property-style`](./docs/rules/class-literal-property-style.md)                     | Ensures that literals on classes are exposed in a consistent style                                                      |                    | :wrench: |                   |
 | [`@typescript-eslint/consistent-type-assertions`](./docs/rules/consistent-type-assertions.md)                         | Enforces consistent usage of type assertions                                                                            | :heavy_check_mark: |          |                   |
 | [`@typescript-eslint/consistent-type-definitions`](./docs/rules/consistent-type-definitions.md)                       | Consistent with type definition either `interface` or `type`                                                            |                    | :wrench: |                   |
 | [`@typescript-eslint/explicit-function-return-type`](./docs/rules/explicit-function-return-type.md)                   | Require explicit return types on functions and class methods                                                            | :heavy_check_mark: |          |                   |
diff --git a/packages/eslint-plugin/docs/rules/class-literal-property-style.md b/packages/eslint-plugin/docs/rules/class-literal-property-style.md
new file mode 100644
index 00000000000..903a695dd76
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/class-literal-property-style.md
@@ -0,0 +1,96 @@
+# Ensures that literals on classes are exposed in a consistent style (`class-literal-property-style`)
+
+When writing TypeScript applications, it's typically safe to store literal values on classes using fields with the `readonly` modifier to prevent them from being reassigned.
+When writing TypeScript libraries that could be used by Javascript users however, it's typically safer to expose these literals using `getter`s, since the `readonly` modifier is enforced at compile type.
+
+## Rule Details
+
+This rule aims to ensure that literals exposed by classes are done so consistently, in one of the two style described above.
+By default this rule prefers the `fields` style as it means JS doesn't have to setup & teardown a function closure.
+
+Note that this rule only checks for constant _literal_ values (string, template string, number, bigint, boolean, regexp, null). It does not check objects or arrays, because a readonly field behaves differently to a getter in those cases. It also does not check functions, as it is a common pattern to use readonly fields with arrow function values as auto-bound methods.
+This is because these types can be mutated and carry with them more complex implications about their usage.
+
+#### The `fields` style
+
+This style checks for any getter methods that return literal values, and requires them to be defined using fields with the `readonly` modifier instead.
+
+Examples of **correct** code with the `fields` style:
+
+```ts
+/* eslint @typescript-eslint/class-literal-property-style: ["error", "fields"] */
+
+class Mx {
+  public readonly myField1 = 1;
+
+  // not a literal
+  public readonly myField2 = [1, 2, 3];
+
+  private readonly ['myField3'] = 'hello world';
+
+  public get myField4() {
+    return `hello from ${window.location.href}`;
+  }
+}
+```
+
+Examples of **incorrect** code with the `fields` style:
+
+```ts
+/* eslint @typescript-eslint/class-literal-property-style: ["error", "fields"] */
+
+class Mx {
+  public static get myField1() {
+    return 1;
+  }
+
+  private get ['myField2']() {
+    return 'hello world';
+  }
+}
+```
+
+#### The `getters` style
+
+This style checks for any `readonly` fields that are assigned literal values, and requires them to be defined as getters instead.
+This style pairs well with the [`@typescript-eslint/prefer-readonly`](prefer-readonly.md) rule,
+as it will identify fields that can be `readonly`, and thus should be made into getters.
+
+Examples of **correct** code with the `getters` style:
+
+```ts
+/* eslint @typescript-eslint/class-literal-property-style: ["error", "getters"] */
+
+class Mx {
+  // no readonly modifier
+  public myField1 = 'hello';
+
+  // not a literal
+  public readonly myField2 = [1, 2, 3];
+
+  public static get myField3() {
+    return 1;
+  }
+
+  private get ['myField4']() {
+    return 'hello world';
+  }
+}
+```
+
+Examples of **incorrect** code with the `getters` style:
+
+```ts
+/* eslint @typescript-eslint/class-literal-property-style: ["error", "getters"] */
+
+class Mx {
+  readonly myField1 = 1;
+  readonly myField2 = `hello world`;
+  private readonly myField3 = 'hello world';
+}
+```
+
+## When Not To Use It
+
+When you have no strong preference, or do not wish to enforce a particular style
+for how literal values are exposed by your classes.
diff --git a/packages/eslint-plugin/src/configs/all.json b/packages/eslint-plugin/src/configs/all.json
index 2626767b84c..c5575d4970d 100644
--- a/packages/eslint-plugin/src/configs/all.json
+++ b/packages/eslint-plugin/src/configs/all.json
@@ -8,6 +8,7 @@
     "@typescript-eslint/ban-types": "error",
     "brace-style": "off",
     "@typescript-eslint/brace-style": "error",
+    "@typescript-eslint/class-literal-property-style": "error",
     "comma-spacing": "off",
     "@typescript-eslint/comma-spacing": "error",
     "@typescript-eslint/consistent-type-assertions": "error",
diff --git a/packages/eslint-plugin/src/rules/class-literal-property-style.ts b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
new file mode 100644
index 00000000000..a4500cdfdbf
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/class-literal-property-style.ts
@@ -0,0 +1,136 @@
+import {
+  AST_NODE_TYPES,
+  TSESTree,
+} from '@typescript-eslint/experimental-utils';
+import * as util from '../util';
+
+type Options = ['fields' | 'getters'];
+type MessageIds = 'preferFieldStyle' | 'preferGetterStyle';
+
+interface NodeWithModifiers {
+  accessibility?: TSESTree.Accessibility;
+  static: boolean;
+}
+
+const printNodeModifiers = (
+  node: NodeWithModifiers,
+  final: 'readonly' | 'get',
+): string =>
+  `${node.accessibility ?? ''}${
+    node.static ? ' static' : ''
+  } ${final} `.trimLeft();
+
+const isSupportedLiteral = (
+  node: TSESTree.Node,
+): node is TSESTree.LiteralExpression => {
+  if (
+    node.type === AST_NODE_TYPES.Literal ||
+    node.type === AST_NODE_TYPES.BigIntLiteral
+  ) {
+    return true;
+  }
+
+  if (
+    node.type === AST_NODE_TYPES.TaggedTemplateExpression ||
+    node.type === AST_NODE_TYPES.TemplateLiteral
+  ) {
+    return ('quasi' in node ? node.quasi.quasis : node.quasis).length === 1;
+  }
+
+  return false;
+};
+
+export default util.createRule<Options, MessageIds>({
+  name: 'class-literal-property-style',
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Ensures that literals on classes are exposed in a consistent style',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    fixable: 'code',
+    messages: {
+      preferFieldStyle: 'Literals should be exposed using readonly fields.',
+      preferGetterStyle: 'Literals should be exposed using getters.',
+    },
+    schema: [{ enum: ['fields', 'getters'] }],
+  },
+  defaultOptions: ['fields'],
+  create(context, [style]) {
+    if (style === 'fields') {
+      return {
+        MethodDefinition(node: TSESTree.MethodDefinition): void {
+          if (
+            node.kind !== 'get' ||
+            !node.value.body ||
+            !node.value.body.body.length
+          ) {
+            return;
+          }
+
+          const [statement] = node.value.body.body;
+
+          if (statement.type !== AST_NODE_TYPES.ReturnStatement) {
+            return;
+          }
+
+          const { argument } = statement;
+
+          if (!argument || !isSupportedLiteral(argument)) {
+            return;
+          }
+
+          context.report({
+            node: node.key,
+            messageId: 'preferFieldStyle',
+            fix(fixer) {
+              const sourceCode = context.getSourceCode();
+              const name = sourceCode.getText(node.key);
+
+              let text = '';
+
+              text += printNodeModifiers(node, 'readonly');
+              text += node.computed ? `[${name}]` : name;
+              text += ` = ${sourceCode.getText(argument)};`;
+
+              return fixer.replaceText(node, text);
+            },
+          });
+        },
+      };
+    }
+
+    return {
+      ClassProperty(node: TSESTree.ClassProperty): void {
+        if (!node.readonly || node.declare) {
+          return;
+        }
+
+        const { value } = node;
+
+        if (!value || !isSupportedLiteral(value)) {
+          return;
+        }
+
+        context.report({
+          node: node.key,
+          messageId: 'preferGetterStyle',
+          fix(fixer) {
+            const sourceCode = context.getSourceCode();
+            const name = sourceCode.getText(node.key);
+
+            let text = '';
+
+            text += printNodeModifiers(node, 'get');
+            text += node.computed ? `[${name}]` : name;
+            text += `() { return ${sourceCode.getText(value)}; }`;
+
+            return fixer.replaceText(node, text);
+          },
+        });
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
index 486b8a97945..29db58b681a 100644
--- a/packages/eslint-plugin/src/rules/index.ts
+++ b/packages/eslint-plugin/src/rules/index.ts
@@ -7,6 +7,7 @@ import banTypes from './ban-types';
 import braceStyle from './brace-style';
 import camelcase from './camelcase';
 import classNameCasing from './class-name-casing';
+import classLiteralPropertyStyle from './class-literal-property-style';
 import commaSpacing from './comma-spacing';
 import consistentTypeAssertions from './consistent-type-assertions';
 import consistentTypeDefinitions from './consistent-type-definitions';
@@ -102,6 +103,7 @@ export default {
   'brace-style': braceStyle,
   camelcase: camelcase,
   'class-name-casing': classNameCasing,
+  'class-literal-property-style': classLiteralPropertyStyle,
   'comma-spacing': commaSpacing,
   'consistent-type-assertions': consistentTypeAssertions,
   'consistent-type-definitions': consistentTypeDefinitions,
diff --git a/packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts b/packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts
new file mode 100644
index 00000000000..f0c5f2afc05
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts
@@ -0,0 +1,378 @@
+import rule from '../../src/rules/class-literal-property-style';
+import { RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('class-literal-property-style', rule, {
+  valid: [
+    'class Mx { declare readonly p1 = 1; }',
+    'class Mx { readonly p1 = "hello world"; }',
+    'class Mx { p1 = "hello world"; }',
+    'class Mx { static p1 = "hello world"; }',
+    'class Mx { p1: string; }',
+    'class Mx { get p1(); }',
+    'class Mx { get p1() {} }',
+    'abstract class Mx { abstract get p1(): string }',
+    `
+      class Mx {
+        get mySetting() {
+          if(this._aValue) {
+            return 'on';
+          }
+
+          return 'off';
+        }
+      }
+    `,
+    `
+      class Mx {
+        get mySetting() {
+          return \`build-\${process.env.build}\`
+        }
+      }
+    `,
+    `
+      class Mx {
+        getMySetting() {
+          if(this._aValue) {
+            return 'on';
+          }
+
+          return 'off';
+        }
+      }
+    `,
+    `
+      class Mx {
+        public readonly myButton = styled.button\`
+          color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+        \`;
+      }
+    `,
+    {
+      code: `
+        class Mx {
+          public get myButton() {
+            return styled.button\`
+              color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+            \`;
+          }
+        }
+      `,
+      options: ['fields'],
+    },
+    {
+      code: 'class Mx { declare public readonly foo = 1; }',
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { get p1() { return "hello world"; } }',
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { p1 = "hello world"; }',
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { p1: string; }',
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { readonly p1 = [1, 2, 3]; }',
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { static p1: string; }',
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { static get p1() { return "hello world"; } }',
+      options: ['getters'],
+    },
+    {
+      code: `
+        class Mx {
+          public readonly myButton = styled.button\`
+            color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+          \`;
+        }
+      `,
+      options: ['getters'],
+    },
+    {
+      code: `
+        class Mx {
+          public get myButton() {
+            return styled.button\`
+              color: \${props => (props.primary ? 'hotpink' : 'turquoise')};
+            \`;
+          }
+        }
+      `,
+      options: ['getters'],
+    },
+  ],
+  invalid: [
+    {
+      code: 'class Mx { get p1() { return "hello world"; } }',
+      output: 'class Mx { readonly p1 = "hello world"; }',
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 16,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'class Mx { get p1() { return `hello world`; } }',
+      output: 'class Mx { readonly p1 = `hello world`; }',
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 16,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'class Mx { static get p1() { return "hello world"; } }',
+      output: 'class Mx { static readonly p1 = "hello world"; }',
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 23,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code:
+        'class Mx { public static readonly static private public protected get foo() { return 1; } }',
+      output: 'class Mx { public static readonly foo = 1; }',
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 71,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: `
+        class Mx {
+          public get [myValue]() {
+            return 'a literal value';
+          }
+        }
+      `,
+      output: `
+        class Mx {
+          public readonly [myValue] = 'a literal value';
+        }
+      `,
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 23,
+          line: 3,
+        },
+      ],
+    },
+    {
+      code: `
+        class Mx {
+          public get [myValue]() {
+            return 12345n;
+          }
+        }
+      `,
+      output: `
+        class Mx {
+          public readonly [myValue] = 12345n;
+        }
+      `,
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 23,
+          line: 3,
+        },
+      ],
+    },
+    {
+      code: `
+        class Mx {
+          public readonly [myValue] = 'a literal value';
+        }
+      `,
+      output: `
+        class Mx {
+          public get [myValue]() { return 'a literal value'; }
+        }
+      `,
+      errors: [
+        {
+          messageId: 'preferGetterStyle',
+          column: 28,
+          line: 3,
+        },
+      ],
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { readonly p1 = "hello world"; }',
+      output: 'class Mx { get p1() { return "hello world"; } }',
+      errors: [
+        {
+          messageId: 'preferGetterStyle',
+          column: 21,
+          line: 1,
+        },
+      ],
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { readonly p1 = `hello world`; }',
+      output: 'class Mx { get p1() { return `hello world`; } }',
+      errors: [
+        {
+          messageId: 'preferGetterStyle',
+          column: 21,
+          line: 1,
+        },
+      ],
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { static readonly p1 = "hello world"; }',
+      output: 'class Mx { static get p1() { return "hello world"; } }',
+      errors: [
+        {
+          messageId: 'preferGetterStyle',
+          column: 28,
+          line: 1,
+        },
+      ],
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { protected get p1() { return "hello world"; } }',
+      output: 'class Mx { protected readonly p1 = "hello world"; }',
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 26,
+          line: 1,
+        },
+      ],
+      options: ['fields'],
+    },
+    {
+      code: 'class Mx { protected readonly p1 = "hello world"; }',
+      output: 'class Mx { protected get p1() { return "hello world"; } }',
+      errors: [
+        {
+          messageId: 'preferGetterStyle',
+          column: 31,
+          line: 1,
+        },
+      ],
+      options: ['getters'],
+    },
+    {
+      code: 'class Mx { public static get p1() { return "hello world"; } }',
+      output: 'class Mx { public static readonly p1 = "hello world"; }',
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 30,
+          line: 1,
+        },
+      ],
+    },
+    {
+      code: 'class Mx { public static readonly p1 = "hello world"; }',
+      output: 'class Mx { public static get p1() { return "hello world"; } }',
+      errors: [
+        {
+          messageId: 'preferGetterStyle',
+          column: 35,
+          line: 1,
+        },
+      ],
+      options: ['getters'],
+    },
+    {
+      code: `
+        class Mx {
+          public get myValue() {
+            return gql\`
+              {
+                user(id: 5) {
+                  firstName
+                  lastName
+                }
+              }
+            \`;
+          }
+        }
+      `,
+      output: `
+        class Mx {
+          public readonly myValue = gql\`
+              {
+                user(id: 5) {
+                  firstName
+                  lastName
+                }
+              }
+            \`;
+        }
+      `,
+      errors: [
+        {
+          messageId: 'preferFieldStyle',
+          column: 22,
+          line: 3,
+        },
+      ],
+    },
+    {
+      code: `
+        class Mx {
+          public readonly myValue = gql\`
+            {
+              user(id: 5) {
+                firstName
+                lastName
+              }
+            }
+          \`;
+        }
+      `,
+      output: `
+        class Mx {
+          public get myValue() { return gql\`
+            {
+              user(id: 5) {
+                firstName
+                lastName
+              }
+            }
+          \`; }
+        }
+      `,
+      errors: [
+        {
+          messageId: 'preferGetterStyle',
+          column: 27,
+          line: 3,
+        },
+      ],
+      options: ['getters'],
+    },
+  ],
+});

From 9cd3e4fe53c0224c75767a3f127f19b86060e277 Mon Sep 17 00:00:00 2001
From: James Henry <james@henry.sc>
Date: Mon, 23 Mar 2020 17:02:04 +0000
Subject: [PATCH 02/36] chore: publish v2.25.0

---
 CHANGELOG.md                                 | 23 ++++++++++++++++++++
 lerna.json                                   |  2 +-
 packages/eslint-plugin-internal/CHANGELOG.md |  8 +++++++
 packages/eslint-plugin-internal/package.json |  4 ++--
 packages/eslint-plugin-tslint/CHANGELOG.md   | 11 ++++++++++
 packages/eslint-plugin-tslint/package.json   |  6 ++---
 packages/eslint-plugin/CHANGELOG.md          | 20 +++++++++++++++++
 packages/eslint-plugin/package.json          |  4 ++--
 packages/experimental-utils/CHANGELOG.md     | 11 ++++++++++
 packages/experimental-utils/package.json     |  4 ++--
 packages/parser/CHANGELOG.md                 |  8 +++++++
 packages/parser/package.json                 |  8 +++----
 packages/shared-fixtures/CHANGELOG.md        |  8 +++++++
 packages/shared-fixtures/package.json        |  2 +-
 packages/typescript-estree/CHANGELOG.md      | 11 ++++++++++
 packages/typescript-estree/package.json      |  4 ++--
 16 files changed, 117 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9d1da108f54..df5d4854494 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,29 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+
+### Bug Fixes
+
+* only run publish_canary_version on master ([3814d4e](https://github.com/typescript-eslint/typescript-eslint/commit/3814d4e3b3c1552c7601b5d722b2a37c5a570841))
+* **eslint-plugin:** [quotes] false positive with backtick in import equals statement ([#1769](https://github.com/typescript-eslint/typescript-eslint/issues/1769)) ([199863d](https://github.com/typescript-eslint/typescript-eslint/commit/199863d35cb36bdb7178b8116d146258506644c7))
+* **eslint-plugin:** fix message of no-base-to-string ([#1755](https://github.com/typescript-eslint/typescript-eslint/issues/1755)) ([6646959](https://github.com/typescript-eslint/typescript-eslint/commit/6646959b255b08afe5175bba6621bad11b9e1d5e))
+* **eslint-plugin-tslint:** fix tslintConfig memoization key ([#1719](https://github.com/typescript-eslint/typescript-eslint/issues/1719)) ([abf1a2f](https://github.com/typescript-eslint/typescript-eslint/commit/abf1a2fa5574e41af8070be3d79a886ea2f989cc)), closes [typescript-eslint#1692](https://github.com/typescript-eslint/issues/1692)
+* **typescript-estree:** export * regression from 133f622f ([#1751](https://github.com/typescript-eslint/typescript-eslint/issues/1751)) ([09d8afc](https://github.com/typescript-eslint/typescript-eslint/commit/09d8afca684635b5ac604bc1794240484a70ce91))
+
+
+### Features
+
+* **eslint-plugin:** [no-unnec-type-assertion] allow const assertions ([#1741](https://github.com/typescript-eslint/typescript-eslint/issues/1741)) ([f76a1b3](https://github.com/typescript-eslint/typescript-eslint/commit/f76a1b3e63afda9f239e46f4ad5b36c1d7a6e8da))
+* **eslint-plugin:** [no-unnecessary-condition] ignore basic array indexing false positives ([#1534](https://github.com/typescript-eslint/typescript-eslint/issues/1534)) ([2b9603d](https://github.com/typescript-eslint/typescript-eslint/commit/2b9603d868c57556d8cd6087685e798d74cb6f26))
+* **eslint-plugin:** add `class-literal-property-style` rule ([#1582](https://github.com/typescript-eslint/typescript-eslint/issues/1582)) ([b2dbd89](https://github.com/typescript-eslint/typescript-eslint/commit/b2dbd890a5bef81aa6978d68c166457838ee04a1))
+* **experimental-utils:** expose ast utility functions ([#1670](https://github.com/typescript-eslint/typescript-eslint/issues/1670)) ([3eb5d45](https://github.com/typescript-eslint/typescript-eslint/commit/3eb5d4525e95c8ab990f55588b8d830a02ce5a9c))
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 
diff --git a/lerna.json b/lerna.json
index b6ba0964df8..f7a5aa4c731 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "2.24.0",
+  "version": "2.25.0",
   "npmClient": "yarn",
   "useWorkspaces": true,
   "stream": true
diff --git a/packages/eslint-plugin-internal/CHANGELOG.md b/packages/eslint-plugin-internal/CHANGELOG.md
index e8e1b2cb841..42a8af8be87 100644
--- a/packages/eslint-plugin-internal/CHANGELOG.md
+++ b/packages/eslint-plugin-internal/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.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+**Note:** Version bump only for package @typescript-eslint/eslint-plugin-internal
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 **Note:** Version bump only for package @typescript-eslint/eslint-plugin-internal
diff --git a/packages/eslint-plugin-internal/package.json b/packages/eslint-plugin-internal/package.json
index a318b9d4571..afbc489b9ba 100644
--- a/packages/eslint-plugin-internal/package.json
+++ b/packages/eslint-plugin-internal/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin-internal",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "private": true,
   "main": "dist/index.js",
   "scripts": {
@@ -12,6 +12,6 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.24.0"
+    "@typescript-eslint/experimental-utils": "2.25.0"
   }
 }
diff --git a/packages/eslint-plugin-tslint/CHANGELOG.md b/packages/eslint-plugin-tslint/CHANGELOG.md
index a2fd2d00412..38770408378 100644
--- a/packages/eslint-plugin-tslint/CHANGELOG.md
+++ b/packages/eslint-plugin-tslint/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+
+### Bug Fixes
+
+* **eslint-plugin-tslint:** fix tslintConfig memoization key ([#1719](https://github.com/typescript-eslint/typescript-eslint/issues/1719)) ([abf1a2f](https://github.com/typescript-eslint/typescript-eslint/commit/abf1a2fa5574e41af8070be3d79a886ea2f989cc)), closes [typescript-eslint#1692](https://github.com/typescript-eslint/issues/1692)
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 **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 10ea4787726..a10074080b2 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": "2.24.0",
+  "version": "2.25.0",
   "main": "dist/index.js",
   "typings": "src/index.ts",
   "description": "TSLint wrapper plugin for ESLint",
@@ -31,7 +31,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.24.0",
+    "@typescript-eslint/experimental-utils": "2.25.0",
     "lodash": "^4.17.15"
   },
   "peerDependencies": {
@@ -41,6 +41,6 @@
   },
   "devDependencies": {
     "@types/lodash": "^4.14.149",
-    "@typescript-eslint/parser": "2.24.0"
+    "@typescript-eslint/parser": "2.25.0"
   }
 }
diff --git a/packages/eslint-plugin/CHANGELOG.md b/packages/eslint-plugin/CHANGELOG.md
index 56a3265aba7..074bd66c7ca 100644
--- a/packages/eslint-plugin/CHANGELOG.md
+++ b/packages/eslint-plugin/CHANGELOG.md
@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+
+### Bug Fixes
+
+* **eslint-plugin:** [quotes] false positive with backtick in import equals statement ([#1769](https://github.com/typescript-eslint/typescript-eslint/issues/1769)) ([199863d](https://github.com/typescript-eslint/typescript-eslint/commit/199863d35cb36bdb7178b8116d146258506644c7))
+* **eslint-plugin:** fix message of no-base-to-string ([#1755](https://github.com/typescript-eslint/typescript-eslint/issues/1755)) ([6646959](https://github.com/typescript-eslint/typescript-eslint/commit/6646959b255b08afe5175bba6621bad11b9e1d5e))
+
+
+### Features
+
+* **eslint-plugin:** [no-unnec-type-assertion] allow const assertions ([#1741](https://github.com/typescript-eslint/typescript-eslint/issues/1741)) ([f76a1b3](https://github.com/typescript-eslint/typescript-eslint/commit/f76a1b3e63afda9f239e46f4ad5b36c1d7a6e8da))
+* **eslint-plugin:** [no-unnecessary-condition] ignore basic array indexing false positives ([#1534](https://github.com/typescript-eslint/typescript-eslint/issues/1534)) ([2b9603d](https://github.com/typescript-eslint/typescript-eslint/commit/2b9603d868c57556d8cd6087685e798d74cb6f26))
+* **eslint-plugin:** add `class-literal-property-style` rule ([#1582](https://github.com/typescript-eslint/typescript-eslint/issues/1582)) ([b2dbd89](https://github.com/typescript-eslint/typescript-eslint/commit/b2dbd890a5bef81aa6978d68c166457838ee04a1))
+* **experimental-utils:** expose ast utility functions ([#1670](https://github.com/typescript-eslint/typescript-eslint/issues/1670)) ([3eb5d45](https://github.com/typescript-eslint/typescript-eslint/commit/3eb5d4525e95c8ab990f55588b8d830a02ce5a9c))
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 **Note:** Version bump only for package @typescript-eslint/eslint-plugin
diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json
index 4855beab6a2..cb725f5be6d 100644
--- a/packages/eslint-plugin/package.json
+++ b/packages/eslint-plugin/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "description": "TypeScript plugin for ESLint",
   "keywords": [
     "eslint",
@@ -41,7 +41,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.24.0",
+    "@typescript-eslint/experimental-utils": "2.25.0",
     "functional-red-black-tree": "^1.0.1",
     "regexpp": "^3.0.0",
     "tsutils": "^3.17.1"
diff --git a/packages/experimental-utils/CHANGELOG.md b/packages/experimental-utils/CHANGELOG.md
index 33f3bce56c0..6a731bc439b 100644
--- a/packages/experimental-utils/CHANGELOG.md
+++ b/packages/experimental-utils/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+
+### Features
+
+* **experimental-utils:** expose ast utility functions ([#1670](https://github.com/typescript-eslint/typescript-eslint/issues/1670)) ([3eb5d45](https://github.com/typescript-eslint/typescript-eslint/commit/3eb5d4525e95c8ab990f55588b8d830a02ce5a9c))
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 **Note:** Version bump only for package @typescript-eslint/experimental-utils
diff --git a/packages/experimental-utils/package.json b/packages/experimental-utils/package.json
index 287b52001c6..52b42129a61 100644
--- a/packages/experimental-utils/package.json
+++ b/packages/experimental-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/experimental-utils",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "description": "(Experimental) Utilities for working with TypeScript + ESLint together",
   "keywords": [
     "eslint",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@types/json-schema": "^7.0.3",
-    "@typescript-eslint/typescript-estree": "2.24.0",
+    "@typescript-eslint/typescript-estree": "2.25.0",
     "eslint-scope": "^5.0.0",
     "eslint-utils": "^2.0.0"
   },
diff --git a/packages/parser/CHANGELOG.md b/packages/parser/CHANGELOG.md
index 6f5b20e66e8..ce9056408ac 100644
--- a/packages/parser/CHANGELOG.md
+++ b/packages/parser/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.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+**Note:** Version bump only for package @typescript-eslint/parser
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 
diff --git a/packages/parser/package.json b/packages/parser/package.json
index da6fbd2b5e8..33047db7557 100644
--- a/packages/parser/package.json
+++ b/packages/parser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/parser",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "description": "An ESLint custom parser which leverages TypeScript ESTree",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
@@ -43,13 +43,13 @@
   },
   "dependencies": {
     "@types/eslint-visitor-keys": "^1.0.0",
-    "@typescript-eslint/experimental-utils": "2.24.0",
-    "@typescript-eslint/typescript-estree": "2.24.0",
+    "@typescript-eslint/experimental-utils": "2.25.0",
+    "@typescript-eslint/typescript-estree": "2.25.0",
     "eslint-visitor-keys": "^1.1.0"
   },
   "devDependencies": {
     "@types/glob": "^7.1.1",
-    "@typescript-eslint/shared-fixtures": "2.24.0",
+    "@typescript-eslint/shared-fixtures": "2.25.0",
     "glob": "*"
   },
   "peerDependenciesMeta": {
diff --git a/packages/shared-fixtures/CHANGELOG.md b/packages/shared-fixtures/CHANGELOG.md
index 70196052327..535e49bbb58 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.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+**Note:** Version bump only for package @typescript-eslint/shared-fixtures
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 
diff --git a/packages/shared-fixtures/package.json b/packages/shared-fixtures/package.json
index 360b466615b..4775ceb0f14 100644
--- a/packages/shared-fixtures/package.json
+++ b/packages/shared-fixtures/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/shared-fixtures",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "private": true,
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
diff --git a/packages/typescript-estree/CHANGELOG.md b/packages/typescript-estree/CHANGELOG.md
index b52cddede33..91b7426e23d 100644
--- a/packages/typescript-estree/CHANGELOG.md
+++ b/packages/typescript-estree/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
+
+
+### Bug Fixes
+
+* **typescript-estree:** export * regression from 133f622f ([#1751](https://github.com/typescript-eslint/typescript-eslint/issues/1751)) ([09d8afc](https://github.com/typescript-eslint/typescript-eslint/commit/09d8afca684635b5ac604bc1794240484a70ce91))
+
+
+
+
+
 # [2.24.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.23.0...v2.24.0) (2020-03-16)
 
 
diff --git a/packages/typescript-estree/package.json b/packages/typescript-estree/package.json
index 9375c156787..20ce7e15b5a 100644
--- a/packages/typescript-estree/package.json
+++ b/packages/typescript-estree/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "2.24.0",
+  "version": "2.25.0",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
@@ -58,7 +58,7 @@
     "@types/lodash": "^4.14.149",
     "@types/semver": "^6.2.0",
     "@types/tmp": "^0.1.0",
-    "@typescript-eslint/shared-fixtures": "2.24.0",
+    "@typescript-eslint/shared-fixtures": "2.25.0",
     "tmp": "^0.1.0",
     "typescript": "*"
   },

From 258fdd059526175431dbfe60dc88e0cc9d99c33e Mon Sep 17 00:00:00 2001
From: tieTYT <tieTYT@gmail.com>
Date: Mon, 23 Mar 2020 13:26:19 -0700
Subject: [PATCH 03/36] docs: title wording in root readme (#1787)

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 95cfe76c5eb..c298f806950 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@
 
 ## Table of Contents
 
-- [Getting Started](#getting-started)
+- [Getting Started / Installation](#getting-started--installation)
 - [What are ESLint and TypeScript, and how do they compare?](#what-are-eslint-and-typescript-and-how-do-they-compare)
 - [Why does this project exist?](#why-does-this-project-exist)
 - [What about TSLint?](#what-about-tslint)
@@ -32,7 +32,7 @@
 - [Contributors](#contributors)
 - [Contributing Guide](#contributing-guide)
 
-## Getting Started
+## Getting Started / Installation
 
 - **[You can find our Getting Started docs here](./docs/getting-started/README.md)**
 - **[You can find our Linting FAQ / Troubleshooting docs here](./docs/getting-started/linting/FAQ.md)**

From b1b82847aa1db5040b18daf7b601f9c63c96a99c Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Mon, 23 Mar 2020 16:06:15 -0700
Subject: [PATCH 04/36] docs(eslint-plugin): [prefer-readonly-parameter-types]
 fix invalid example (#1791)

---
 .../docs/rules/prefer-readonly-parameter-types.md              | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/docs/rules/prefer-readonly-parameter-types.md b/packages/eslint-plugin/docs/rules/prefer-readonly-parameter-types.md
index c69b3b21c34..74697f2d3e6 100644
--- a/packages/eslint-plugin/docs/rules/prefer-readonly-parameter-types.md
+++ b/packages/eslint-plugin/docs/rules/prefer-readonly-parameter-types.md
@@ -74,7 +74,8 @@ function object3(arg: { readonly prop: { readonly prop2: string } }) {}
 interface CustomArrayType extends ReadonlyArray<string> {
   readonly prop: string;
 }
-function custom1(arg: CustomArrayType) {}
+function custom1(arg: Readonly<CustomArrayType>) {}
+// interfaces that extend the array types are not considered arrays, and thus must be made readonly.
 
 interface CustomFunction {
   (): void;

From 4fa710754ecc412b65ac3864fe0c7857c254ac1b Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Wed, 25 Mar 2020 20:09:04 -0700
Subject: [PATCH 05/36] fix(eslint-plugin): [no-unsafe-call] allow import
 expressions (#1800)

---
 packages/eslint-plugin/src/rules/no-unsafe-call.ts        | 6 +++---
 packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index 42630181936..13cabc87d92 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -41,10 +41,10 @@ export default util.createRule<[], MessageIds>({
     }
 
     return {
-      'CallExpression, OptionalCallExpression'(
-        node: TSESTree.CallExpression | TSESTree.OptionalCallExpression,
+      ':matches(CallExpression, OptionalCallExpression) > :not(Import)'(
+        node: Exclude<TSESTree.LeftHandSideExpression, TSESTree.Import>,
       ): void {
-        checkCall(node.callee, node.callee, 'unsafeCall');
+        checkCall(node, node, 'unsafeCall');
       },
       NewExpression(node): void {
         checkCall(node.callee, node, 'unsafeNew');
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
index 1930db27326..a51273c9b9c 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
@@ -20,6 +20,7 @@ ruleTester.run('no-unsafe-call', rule, {
     'function foo(x: { a?: () => void }) { x.a?.() }',
     'new Map()',
     'String.raw`foo`',
+    'const x = import("./foo");',
   ],
   invalid: [
     ...batchedSingleLineTests({

From 638d84ddd77d07117b3ec7c5431f3b0e44b1995d Mon Sep 17 00:00:00 2001
From: doniyor2109 <doniyor2109@gmail.com>
Date: Thu, 26 Mar 2020 13:04:48 +0500
Subject: [PATCH 06/36] fix(eslint-plugin): [no-explicit-any] error with
 ignoreRestArgs (#1796)

---
 packages/eslint-plugin/src/rules/no-explicit-any.ts   |  9 ++-------
 .../eslint-plugin/tests/rules/no-explicit-any.test.ts | 11 +++++++++++
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index 29fb16651a2..91765c40e26 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -131,9 +131,7 @@ export default util.createRule<Options, MessageIds>({
      */
     function isGreatGrandparentRestElement(node: TSESTree.Node): boolean {
       return (
-        typeof node.parent !== 'undefined' &&
-        typeof node.parent.parent !== 'undefined' &&
-        typeof node.parent.parent.parent !== 'undefined' &&
+        node?.parent?.parent?.parent != null &&
         isNodeRestElementInFunction(node.parent.parent.parent)
       );
     }
@@ -146,11 +144,8 @@ export default util.createRule<Options, MessageIds>({
      */
     function isGreatGreatGrandparentRestElement(node: TSESTree.Node): boolean {
       return (
-        typeof node.parent !== 'undefined' &&
-        typeof node.parent.parent !== 'undefined' &&
+        node.parent?.parent?.parent?.parent != null &&
         isNodeValidTSType(node.parent.parent) &&
-        typeof node.parent.parent.parent !== 'undefined' &&
-        typeof node.parent.parent.parent.parent !== 'undefined' &&
         isNodeRestElementInFunction(node.parent.parent.parent.parent)
       );
     }
diff --git a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
index d065c410987..fa68b09919e 100644
--- a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
@@ -925,6 +925,17 @@ const test = <T extends Partial<never>>() => {};
         },
       ],
     },
+    {
+      code: `type Any = any;`,
+      options: [{ ignoreRestArgs: true }],
+      errors: [
+        {
+          messageId: 'unexpectedAny',
+          line: 1,
+          column: 12,
+        },
+      ],
+    },
     {
       code: `function foo5(...args: any) {}`,
       options: [{ ignoreRestArgs: true }],

From 7d963fd846935acd91b7b0cd31c56a70a2b994d1 Mon Sep 17 00:00:00 2001
From: crfrolik <60711200+crfrolik@users.noreply.github.com>
Date: Thu, 26 Mar 2020 14:53:43 -0400
Subject: [PATCH 07/36] feat(eslint-plugin-tslint): support tslint 6 (#1809)

---
 package.json                               |  2 +-
 packages/eslint-plugin-tslint/package.json |  2 +-
 yarn.lock                                  | 17 +++++++++++------
 3 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/package.json b/package.json
index db9c7201528..5aa87589e19 100644
--- a/package.json
+++ b/package.json
@@ -73,7 +73,7 @@
     "prettier": "^1.19.1",
     "ts-jest": "^25.0.0",
     "ts-node": "^8.5.0",
-    "tslint": "^5.20.1",
+    "tslint": "^6.1.0",
     "typescript": ">=3.2.1 <3.9.0"
   },
   "resolutions": {
diff --git a/packages/eslint-plugin-tslint/package.json b/packages/eslint-plugin-tslint/package.json
index a10074080b2..1c422e8fa11 100644
--- a/packages/eslint-plugin-tslint/package.json
+++ b/packages/eslint-plugin-tslint/package.json
@@ -36,7 +36,7 @@
   },
   "peerDependencies": {
     "eslint": "^5.0.0 || ^6.0.0",
-    "tslint": "^5.0.0",
+    "tslint": "^5.0.0 || ^6.0.0",
     "typescript": "*"
   },
   "devDependencies": {
diff --git a/yarn.lock b/yarn.lock
index 4e2a78cbd7e..8fb6fd0a838 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -8065,15 +8065,20 @@ ts-node@^8.5.0:
     source-map-support "^0.5.6"
     yn "^3.0.0"
 
-tslib@^1.8.0, tslib@^1.8.1, tslib@^1.9.0:
+tslib@^1.10.0:
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.11.1.tgz#eb15d128827fbee2841549e171f45ed338ac7e35"
+  integrity sha512-aZW88SY8kQbU7gpV19lN24LtXh/yD4ZZg6qieAJDDg+YBsJcSmLGK9QpnUjAKVG/xefmvJGd1WUmfpT/g6AJGA==
+
+tslib@^1.8.1, tslib@^1.9.0:
   version "1.10.0"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.10.0.tgz#c3c19f95973fb0a62973fb09d90d961ee43e5c8a"
   integrity sha512-qOebF53frne81cf0S9B41ByenJ3/IuH8yJKngAX35CmiZySA0khhkovshKK+jGCaMnVomla7gVlIcc3EvKPbTQ==
 
-tslint@^5.20.1:
-  version "5.20.1"
-  resolved "https://registry.yarnpkg.com/tslint/-/tslint-5.20.1.tgz#e401e8aeda0152bc44dd07e614034f3f80c67b7d"
-  integrity sha512-EcMxhzCFt8k+/UP5r8waCf/lzmeSyVlqxqMEDQE7rWYiQky8KpIBz1JAoYXfROHrPZ1XXd43q8yQnULOLiBRQg==
+tslint@^6.1.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/tslint/-/tslint-6.1.0.tgz#c6c611b8ba0eed1549bf5a59ba05a7732133d851"
+  integrity sha512-fXjYd/61vU6da04E505OZQGb2VCN2Mq3doeWcOIryuG+eqdmFUXTYVwdhnbEu2k46LNLgUYt9bI5icQze/j0bQ==
   dependencies:
     "@babel/code-frame" "^7.0.0"
     builtin-modules "^1.1.1"
@@ -8086,7 +8091,7 @@ tslint@^5.20.1:
     mkdirp "^0.5.1"
     resolve "^1.3.2"
     semver "^5.3.0"
-    tslib "^1.8.0"
+    tslib "^1.10.0"
     tsutils "^2.29.0"
 
 tsutils@^2.29.0:

From 1e29e69b289d61107a7de67592beae331ba50222 Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Fri, 27 Mar 2020 09:31:51 -0700
Subject: [PATCH 08/36] feat(typescript-estree): add option to ignore certain
 folders from glob resolution (#1802)

---
 .../src/ts-eslint/ParserOptions.ts            |   1 +
 packages/parser/README.md                     |  19 +++-
 packages/typescript-estree/README.md          |  11 ++
 .../typescript-estree/src/parser-options.ts   |  91 +++++++++-------
 packages/typescript-estree/src/parser.ts      | 100 ++++++++++++++----
 .../projectFolderIgnoreList/ignoreme/file.ts  |   1 +
 .../ignoreme/tsconfig.json                    |   3 +
 .../projectFolderIgnoreList/includeme/file.ts |   1 +
 .../includeme/tsconfig.json                   |   3 +
 packages/typescript-estree/tests/lib/parse.ts |  45 ++++++++
 tsconfig.eslint.json                          |   2 +-
 11 files changed, 213 insertions(+), 64 deletions(-)
 create mode 100644 packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/file.ts
 create mode 100644 packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/tsconfig.json
 create mode 100644 packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/file.ts
 create mode 100644 packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/tsconfig.json

diff --git a/packages/experimental-utils/src/ts-eslint/ParserOptions.ts b/packages/experimental-utils/src/ts-eslint/ParserOptions.ts
index d6bf57bb585..0ff55c81c56 100644
--- a/packages/experimental-utils/src/ts-eslint/ParserOptions.ts
+++ b/packages/experimental-utils/src/ts-eslint/ParserOptions.ts
@@ -16,6 +16,7 @@ interface ParserOptions {
   loc?: boolean;
   noWatch?: boolean;
   project?: string | string[];
+  projectFolderIgnoreList?: (string | RegExp)[];
   range?: boolean;
   sourceType?: 'script' | 'module';
   tokens?: boolean;
diff --git a/packages/parser/README.md b/packages/parser/README.md
index cf69891fb7a..70cb1cb2ca2 100644
--- a/packages/parser/README.md
+++ b/packages/parser/README.md
@@ -54,6 +54,7 @@ interface ParserOptions {
     jsx?: boolean;
   };
   project?: string | string[];
+  projectFolderIgnoreList?: (string | RegExp)[];
   tsconfigRootDir?: string;
   extraFileExtensions?: string[];
   warnOnUnsupportedTypeScriptVersion?: boolean;
@@ -118,26 +119,36 @@ This option allows you to provide a path to your project's `tsconfig.json`. **Th
   }
   ```
 
-### `tsconfigRootDir`
+### `parserOptions.tsconfigRootDir`
 
 Default `undefined`.
 
 This option allows you to provide the root directory for relative tsconfig paths specified in the `project` option above.
 
-### `extraFileExtensions`
+### `parserOptions.projectFolderIgnoreList`
+
+Default `["/node_modules/"]`.
+
+This option allows you to ignore folders from being included in your provided list of `project`s.
+Any resolved project path that matches one or more of the provided regular expressions will be removed from the list.
+This is useful if you have configured glob patterns, but want to make sure you ignore certain folders.
+
+For example, by default it will ensure that a glob like `./**/tsconfig.json` will not match any `tsconfig`s within your `node_modules` folder (some npm packages do not exclude their source files from their published packages).
+
+### `parserOptions.extraFileExtensions`
 
 Default `undefined`.
 
 This option allows you to provide one or more additional file extensions which should be considered in the TypeScript Program compilation.
 The default extensions are `.ts`, `.tsx`, `.js`, and `.jsx`. Add extensions starting with `.`, followed by the file extension. E.g. for a `.vue` file use `"extraFileExtensions: [".vue"]`.
 
-### `warnOnUnsupportedTypeScriptVersion`
+### `parserOptions.warnOnUnsupportedTypeScriptVersion`
 
 Default `true`.
 
 This option allows you to toggle the warning that the parser will give you if you use a version of TypeScript which is not explicitly supported
 
-### `createDefaultProgram`
+### `parserOptions.createDefaultProgram`
 
 Default `false`.
 
diff --git a/packages/typescript-estree/README.md b/packages/typescript-estree/README.md
index 54706cf47f9..df2492c56b3 100644
--- a/packages/typescript-estree/README.md
+++ b/packages/typescript-estree/README.md
@@ -182,6 +182,16 @@ interface ParseAndGenerateServicesOptions extends ParseOptions {
    */
   project?: string | string[];
 
+  /**
+   * If you provide a glob (or globs) to the project option, you can use this option to blacklist
+   * certain folders from being matched by the globs.
+   * Any project path that matches one or more of the provided regular expressions will be removed from the list.
+   *
+   * Accepts an array of strings that are passed to new RegExp(), or an array of regular expressions.
+   * By default, this is set to ["/node_modules/"]
+   */
+  projectFolderIgnoreList?: (string | RegExp)[];
+
   /**
    * The absolute path to the root directory for all provided `project`s.
    */
@@ -205,6 +215,7 @@ const PARSE_AND_GENERATE_SERVICES_DEFAULT_OPTIONS: ParseOptions = {
   extraFileExtensions: [],
   preserveNodeMaps: false, // or true, if you do not set this, but pass `project`
   project: undefined,
+  projectFolderIgnoreList: ['/node_modules/'],
   tsconfigRootDir: process.cwd(),
 };
 
diff --git a/packages/typescript-estree/src/parser-options.ts b/packages/typescript-estree/src/parser-options.ts
index 73ea6ba3c04..c55ace5adb0 100644
--- a/packages/typescript-estree/src/parser-options.ts
+++ b/packages/typescript-estree/src/parser-options.ts
@@ -29,28 +29,23 @@ export interface Extra {
 // MAKE SURE THIS IS KEPT IN SYNC WITH THE README //
 ////////////////////////////////////////////////////
 
-export interface TSESTreeOptions {
+interface ParseOptions {
   /**
    * create a top-level comments array containing all comments
    */
   comment?: boolean;
 
   /**
-   * For convenience:
-   * - true === ['typescript-eslint']
-   * - false === []
-   *
    * An array of modules to turn explicit debugging on for.
    * - 'typescript-eslint' is the same as setting the env var `DEBUG=typescript-eslint:*`
    * - 'eslint' is the same as setting the env var `DEBUG=eslint:*`
    * - 'typescript' is the same as setting `extendedDiagnostics: true` in your tsconfig compilerOptions
+   *
+   * For convenience, also supports a boolean:
+   * - true === ['typescript-eslint']
+   * - false === []
    */
-  debugLevel?: boolean | DebugModule[];
-
-  /**
-   * Causes the parser to error if the TypeScript compiler returns any unexpected syntax/semantic errors.
-   */
-  errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
+  debugLevel?: boolean | ('typescript-eslint' | 'eslint' | 'typescript')[];
 
   /**
    * Cause the parser to error if it encounters an unknown AST node type (useful for testing).
@@ -59,14 +54,7 @@ export interface TSESTreeOptions {
   errorOnUnknownASTType?: boolean;
 
   /**
-   * When `project` is provided, this controls the non-standard file extensions which will be parsed.
-   * It accepts an array of file extensions, each preceded by a `.`.
-   */
-  extraFileExtensions?: string[];
-
-  /**
-   * Absolute (or relative to `tsconfigRootDir`) path to the file being parsed.
-   * When `project` is provided, this is required, as it is used to fetch the file from the TypeScript compiler's cache.
+   * Absolute (or relative to `cwd`) path to the file being parsed.
    */
   filePath?: string;
 
@@ -95,6 +83,45 @@ export interface TSESTreeOptions {
    */
   loggerFn?: Function | false;
 
+  /**
+   * Controls whether the `range` property is included on AST nodes.
+   * The `range` property is a [number, number] which indicates the start/end index of the node in the file contents.
+   * This is similar to the `loc` property, except this is the absolute index.
+   */
+  range?: boolean;
+
+  /**
+   * Set to true to create a top-level array containing all tokens from the file.
+   */
+  tokens?: boolean;
+
+  /*
+   * The JSX AST changed the node type for string literals
+   * inside a JSX Element from `Literal` to `JSXText`.
+   * When value is `true`, these nodes will be parsed as type `JSXText`.
+   * When value is `false`, these nodes will be parsed as type `Literal`.
+   */
+  useJSXTextNode?: boolean;
+}
+
+interface ParseAndGenerateServicesOptions extends ParseOptions {
+  /**
+   * Causes the parser to error if the TypeScript compiler returns any unexpected syntax/semantic errors.
+   */
+  errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
+
+  /**
+   * When `project` is provided, this controls the non-standard file extensions which will be parsed.
+   * It accepts an array of file extensions, each preceded by a `.`.
+   */
+  extraFileExtensions?: string[];
+
+  /**
+   * Absolute (or relative to `tsconfigRootDir`) path to the file being parsed.
+   * When `project` is provided, this is required, as it is used to fetch the file from the TypeScript compiler's cache.
+   */
+  filePath?: string;
+
   /**
    * Allows the user to control whether or not two-way AST node maps are preserved
    * during the AST conversion process.
@@ -114,30 +141,20 @@ export interface TSESTreeOptions {
   project?: string | string[];
 
   /**
-   * Controls whether the `range` property is included on AST nodes.
-   * The `range` property is a [number, number] which indicates the start/end index of the node in the file contents.
-   * This is similar to the `loc` property, except this is the absolute index.
-   */
-  range?: boolean;
-
-  /**
-   * Set to true to create a top-level array containing all tokens from the file.
+   * If you provide a glob (or globs) to the project option, you can use this option to blacklist
+   * certain folders from being matched by the globs.
+   * Any project path that matches one or more of the provided regular expressions will be removed from the list.
+   *
+   * Accepts an array of strings that are passed to new RegExp(), or an array of regular expressions.
+   * By default, this is set to ["/node_modules/"]
    */
-  tokens?: boolean;
+  projectFolderIgnoreList?: (string | RegExp)[];
 
   /**
    * The absolute path to the root directory for all provided `project`s.
    */
   tsconfigRootDir?: string;
 
-  /*
-   * The JSX AST changed the node type for string literals
-   * inside a JSX Element from `Literal` to `JSXText`.
-   * When value is `true`, these nodes will be parsed as type `JSXText`.
-   * When value is `false`, these nodes will be parsed as type `Literal`.
-   */
-  useJSXTextNode?: boolean;
-
   /**
    ***************************************************************************************
    * IT IS RECOMMENDED THAT YOU DO NOT USE THIS OPTION, AS IT CAUSES PERFORMANCE ISSUES. *
@@ -150,6 +167,8 @@ export interface TSESTreeOptions {
   createDefaultProgram?: boolean;
 }
 
+export type TSESTreeOptions = ParseAndGenerateServicesOptions;
+
 // This lets us use generics to type the return value, and removes the need to
 // handle the undefined type in the get method
 export interface ParserWeakMap<TKey, TValueBase> {
diff --git a/packages/typescript-estree/src/parser.ts b/packages/typescript-estree/src/parser.ts
index b5e75d15559..5e3e9b90261 100644
--- a/packages/typescript-estree/src/parser.ts
+++ b/packages/typescript-estree/src/parser.ts
@@ -14,6 +14,8 @@ import { getFirstSemanticOrSyntacticError } from './semantic-or-syntactic-errors
 import { TSESTree } from './ts-estree';
 import { ensureAbsolutePath } from './create-program/shared';
 
+const log = debug('typescript-eslint:typescript-estree:parser');
+
 /**
  * This needs to be kept in sync with the top-level README.md in the
  * typescript-eslint monorepo
@@ -111,6 +113,74 @@ function resetExtra(): void {
   };
 }
 
+/**
+ * Normalizes, sanitizes, resolves and filters the provided
+ */
+function prepareAndTransformProjects(
+  projectsInput: string | string[] | undefined,
+  ignoreListInput: (string | RegExp)[] | undefined,
+): string[] {
+  let projects: string[] = [];
+
+  // Normalize and sanitize the project paths
+  if (typeof projectsInput === 'string') {
+    projects.push(projectsInput);
+  } else if (Array.isArray(projectsInput)) {
+    for (const project of projectsInput) {
+      if (typeof project === 'string') {
+        projects.push(project);
+      }
+    }
+  }
+
+  if (projects.length === 0) {
+    return projects;
+  }
+
+  // Transform glob patterns into paths
+  projects = projects.reduce<string[]>(
+    (projects, project) =>
+      projects.concat(
+        isGlob(project)
+          ? globSync(project, {
+              cwd: extra.tsconfigRootDir,
+            })
+          : project,
+      ),
+    [],
+  );
+
+  // Normalize and sanitize the ignore regex list
+  const ignoreRegexes: RegExp[] = [];
+  if (Array.isArray(ignoreListInput)) {
+    for (const ignore of ignoreListInput) {
+      if (ignore instanceof RegExp) {
+        ignoreRegexes.push(ignore);
+      } else if (typeof ignore === 'string') {
+        ignoreRegexes.push(new RegExp(ignore));
+      }
+    }
+  } else {
+    ignoreRegexes.push(/\/node_modules\//);
+  }
+
+  // Remove any paths that match the ignore list
+  const filtered = projects.filter(project => {
+    for (const ignore of ignoreRegexes) {
+      if (ignore.test(project)) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+
+  log('parserOptions.project matched projects: %s', projects);
+  log('ignore list applied to parserOptions.project: %s', filtered);
+
+  return filtered;
+}
+
 function applyParserOptionsToExtra(options: TSESTreeOptions): void {
   /**
    * Configure Debug logging
@@ -205,34 +275,18 @@ function applyParserOptionsToExtra(options: TSESTreeOptions): void {
     extra.log = Function.prototype;
   }
 
-  if (typeof options.project === 'string') {
-    extra.projects = [options.project];
-  } else if (
-    Array.isArray(options.project) &&
-    options.project.every(projectPath => typeof projectPath === 'string')
-  ) {
-    extra.projects = options.project;
-  }
-
   if (typeof options.tsconfigRootDir === 'string') {
     extra.tsconfigRootDir = options.tsconfigRootDir;
   }
+
+  // NOTE - ensureAbsolutePath relies upon having the correct tsconfigRootDir in extra
   extra.filePath = ensureAbsolutePath(extra.filePath, extra);
 
-  // Transform glob patterns into paths
-  if (extra.projects) {
-    extra.projects = extra.projects.reduce<string[]>(
-      (projects, project) =>
-        projects.concat(
-          isGlob(project)
-            ? globSync(project, {
-                cwd: extra.tsconfigRootDir || process.cwd(),
-              })
-            : project,
-        ),
-      [],
-    );
-  }
+  // NOTE - prepareAndTransformProjects relies upon having the correct tsconfigRootDir in extra
+  extra.projects = prepareAndTransformProjects(
+    options.project,
+    options.projectFolderIgnoreList,
+  );
 
   if (
     Array.isArray(options.extraFileExtensions) &&
diff --git a/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/file.ts b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/file.ts
new file mode 100644
index 00000000000..ad1d380d6cc
--- /dev/null
+++ b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/file.ts
@@ -0,0 +1 @@
+export const x = 1;
diff --git a/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/tsconfig.json b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/tsconfig.json
new file mode 100644
index 00000000000..a01e8a941e8
--- /dev/null
+++ b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/ignoreme/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "include": ["./file.ts"]
+}
diff --git a/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/file.ts b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/file.ts
new file mode 100644
index 00000000000..25dfdc46133
--- /dev/null
+++ b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/file.ts
@@ -0,0 +1 @@
+export const x = 2;
diff --git a/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/tsconfig.json b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/tsconfig.json
new file mode 100644
index 00000000000..a01e8a941e8
--- /dev/null
+++ b/packages/typescript-estree/tests/fixtures/projectFolderIgnoreList/includeme/tsconfig.json
@@ -0,0 +1,3 @@
+{
+  "include": ["./file.ts"]
+}
diff --git a/packages/typescript-estree/tests/lib/parse.ts b/packages/typescript-estree/tests/lib/parse.ts
index 1e6a1e97236..c6435508eac 100644
--- a/packages/typescript-estree/tests/lib/parse.ts
+++ b/packages/typescript-estree/tests/lib/parse.ts
@@ -557,4 +557,49 @@ describe('parse()', () => {
       );
     });
   });
+
+  describe('projectFolderIgnoreList', () => {
+    beforeEach(() => {
+      parser.clearCaches();
+    });
+
+    const PROJECT_DIR = resolve(FIXTURES_DIR, '../projectFolderIgnoreList');
+    const code = 'var a = true';
+    const config: TSESTreeOptions = {
+      comment: true,
+      tokens: true,
+      range: true,
+      loc: true,
+      tsconfigRootDir: PROJECT_DIR,
+      project: './**/tsconfig.json',
+    };
+
+    const testParse = (
+      filePath: 'ignoreme' | 'includeme',
+      projectFolderIgnoreList: TSESTreeOptions['projectFolderIgnoreList'] = [],
+    ) => (): void => {
+      parser.parseAndGenerateServices(code, {
+        ...config,
+        projectFolderIgnoreList,
+        filePath: join(PROJECT_DIR, filePath, './file.ts'),
+      });
+    };
+
+    it('ignores nothing when given nothing', () => {
+      expect(testParse('ignoreme')).not.toThrow();
+      expect(testParse('includeme')).not.toThrow();
+    });
+
+    it('ignores a folder when given a string regexp', () => {
+      const ignore = ['/ignoreme/'];
+      expect(testParse('ignoreme', ignore)).toThrow();
+      expect(testParse('includeme', ignore)).not.toThrow();
+    });
+
+    it('ignores a folder when given a RegExp', () => {
+      const ignore = [/\/ignoreme\//];
+      expect(testParse('ignoreme', ignore)).toThrow();
+      expect(testParse('includeme', ignore)).not.toThrow();
+    });
+  });
 });
diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json
index 2d9938163ea..40defd4b3b8 100644
--- a/tsconfig.eslint.json
+++ b/tsconfig.eslint.json
@@ -1,4 +1,4 @@
 {
   "extends": "./tsconfig.base.json",
-  "include": ["tests/**/*.ts", "tools/**/*.ts"]
+  "include": ["tests/**/*.ts", "tools/**/*.ts", ".eslintrc.js"]
 }

From f3160b471f8247e157555b6cf5b40a1f6ccdc233 Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Fri, 27 Mar 2020 18:31:43 -0700
Subject: [PATCH 09/36] fix(eslint-plugin): [no-unsafe-return] error with
 <TS3.7 (#1815)

---
 packages/eslint-plugin/src/util/types.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/src/util/types.ts b/packages/eslint-plugin/src/util/types.ts
index 924c68e151d..f602a1e6a27 100644
--- a/packages/eslint-plugin/src/util/types.ts
+++ b/packages/eslint-plugin/src/util/types.ts
@@ -323,7 +323,12 @@ export function isAnyOrAnyArrayTypeDiscriminated(
   }
   if (
     checker.isArrayType(type) &&
-    isTypeAnyType(checker.getTypeArguments(type)[0])
+    isTypeAnyType(
+      // getTypeArguments was only added in TS3.7
+      checker.getTypeArguments
+        ? checker.getTypeArguments(type)[0]
+        : (type.typeArguments ?? [])[0],
+    )
   ) {
     return AnyType.AnyArray;
   }

From bfdffb4f08274cc28c0ff215d90783af5a6ee423 Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Mon, 30 Mar 2020 00:44:52 -0700
Subject: [PATCH 10/36] chore: separate linting checks to their own step
 (#1801)

If linting/formatting/spelling fails, it should not block running the tests.
If they do block, they can increase the iteration time for contributors, because they will have to fix them before they can see the status of their tests.

By not blocking, a contributor will be able to submit a PR, and come back ~5min later knowing they will be able to see if their code passes linting _and_ tests.

This should also knock ~40-60s off of the perceived runtime, as it parallelises some of the work.
---
 .cspell.json             |  3 ++-
 .github/workflows/ci.yml | 50 +++++++++++++++++++++++++++++++---------
 2 files changed, 41 insertions(+), 12 deletions(-)

diff --git a/.cspell.json b/.cspell.json
index c65ff294c24..7ee50214e7f 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -11,7 +11,8 @@
     "**/**/ROADMAP.md",
     "**/*.{json,snap}",
     ".cspell.json",
-    "yarn.lock"
+    "yarn.lock",
+    ".github/workflows/**"
   ],
   "dictionaries": [
     "typescript",
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 933b4895837..8f6904d879d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -13,7 +13,7 @@ env:
 
 jobs:
   primary_code_validation_and_tests:
-    name: Primary code validation and tests
+    name: Typecheck and tests
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -49,15 +49,6 @@ jobs:
       - name: Typecheck all packages
         run: yarn typecheck
 
-      - name: Check code formatting
-        run: yarn format-check
-
-      - name: Run linting
-        run: yarn lint
-
-      - name: Validate spelling
-        run: yarn check:spelling
-
       - name: Run unit tests
         run: yarn test
         env:
@@ -71,6 +62,43 @@ jobs:
           flags: unittest
           name: codecov
 
+  linting_and_style:
+    name: Code style and lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ env.PRIMARY_NODE_VERSION }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ env.PRIMARY_NODE_VERSION }}
+
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+
+      - uses: actions/cache@v1
+        id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
+        with:
+          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+          key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-yarn-
+
+      # This also runs a build as part of the postinstall bootstrap
+      - name: Install dependencies and build
+        run: |
+          yarn --ignore-engines --frozen-lockfile
+          yarn check-clean-workspace-after-install
+
+      - name: Check code formatting
+        run: yarn format-check
+
+      - name: Run linting
+        run: yarn lint
+
+      - name: Validate spelling
+        run: yarn check:spelling
+
   integration_tests:
     name: Run integration tests on primary Node.js version
     runs-on: ubuntu-latest
@@ -143,7 +171,7 @@ jobs:
   publish_canary_version:
     name: Publish the latest code as a canary version
     runs-on: ubuntu-latest
-    needs: [primary_code_validation_and_tests, unit_tests_on_other_node_versions, integration_tests]
+    needs: [primary_code_validation_and_tests, unit_tests_on_other_node_versions, linting_and_style, integration_tests]
     if: github.ref == 'refs/heads/master'
     steps:
       - uses: actions/checkout@v2

From 543bc795733948f4111388a84c807530b68380dd Mon Sep 17 00:00:00 2001
From: Josh Goldberg <joshuakgoldberg@outlook.com>
Date: Mon, 30 Mar 2020 04:56:39 -0400
Subject: [PATCH 11/36] docs(eslint-plugin): add missing invalid-void link to
 ROADMAP.md (#1816)

---
 packages/eslint-plugin/ROADMAP.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/eslint-plugin/ROADMAP.md b/packages/eslint-plugin/ROADMAP.md
index 32eb363609c..7ca8048769b 100644
--- a/packages/eslint-plugin/ROADMAP.md
+++ b/packages/eslint-plugin/ROADMAP.md
@@ -338,6 +338,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint-
 [`adjacent-overload-signatures`]: https://palantir.github.io/tslint/rules/adjacent-overload-signatures
 [`ban-ts-ignore`]: https://palantir.github.io/tslint/rules/ban-ts-ignore/
 [`ban-types`]: https://palantir.github.io/tslint/rules/ban-types
+[`invalid-void`]: https://palantir.github.io/tslint/rules/invalid-void
 [`member-access`]: https://palantir.github.io/tslint/rules/member-access
 [`member-ordering`]: https://palantir.github.io/tslint/rules/member-ordering
 [`no-any`]: https://palantir.github.io/tslint/rules/no-any

From 151f89b007d3474a4d9b572128388ae4cb3595f7 Mon Sep 17 00:00:00 2001
From: James Henry <james@henry.sc>
Date: Mon, 30 Mar 2020 17:01:55 +0000
Subject: [PATCH 12/36] chore: publish v2.26.0

---
 CHANGELOG.md                                 | 19 +++++++++++++++++++
 lerna.json                                   |  2 +-
 packages/eslint-plugin-internal/CHANGELOG.md |  8 ++++++++
 packages/eslint-plugin-internal/package.json |  4 ++--
 packages/eslint-plugin-tslint/CHANGELOG.md   | 11 +++++++++++
 packages/eslint-plugin-tslint/package.json   |  6 +++---
 packages/eslint-plugin/CHANGELOG.md          | 13 +++++++++++++
 packages/eslint-plugin/package.json          |  4 ++--
 packages/experimental-utils/CHANGELOG.md     | 11 +++++++++++
 packages/experimental-utils/package.json     |  4 ++--
 packages/parser/CHANGELOG.md                 | 11 +++++++++++
 packages/parser/package.json                 |  8 ++++----
 packages/shared-fixtures/CHANGELOG.md        |  8 ++++++++
 packages/shared-fixtures/package.json        |  2 +-
 packages/typescript-estree/CHANGELOG.md      | 11 +++++++++++
 packages/typescript-estree/package.json      |  4 ++--
 16 files changed, 109 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index df5d4854494..c4f8ac29ce3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+
+### Bug Fixes
+
+* **eslint-plugin:** [no-explicit-any] error with ignoreRestArgs ([#1796](https://github.com/typescript-eslint/typescript-eslint/issues/1796)) ([638d84d](https://github.com/typescript-eslint/typescript-eslint/commit/638d84ddd77d07117b3ec7c5431f3b0e44b1995d))
+* **eslint-plugin:** [no-unsafe-call] allow import expressions ([#1800](https://github.com/typescript-eslint/typescript-eslint/issues/1800)) ([4fa7107](https://github.com/typescript-eslint/typescript-eslint/commit/4fa710754ecc412b65ac3864fe0c7857c254ac1b))
+* **eslint-plugin:** [no-unsafe-return] error with <TS3.7 ([#1815](https://github.com/typescript-eslint/typescript-eslint/issues/1815)) ([f3160b4](https://github.com/typescript-eslint/typescript-eslint/commit/f3160b471f8247e157555b6cf5b40a1f6ccdc233))
+
+
+### Features
+
+* **eslint-plugin-tslint:** support tslint 6 ([#1809](https://github.com/typescript-eslint/typescript-eslint/issues/1809)) ([7d963fd](https://github.com/typescript-eslint/typescript-eslint/commit/7d963fd846935acd91b7b0cd31c56a70a2b994d1))
+* **typescript-estree:** add option to ignore certain folders from glob resolution ([#1802](https://github.com/typescript-eslint/typescript-eslint/issues/1802)) ([1e29e69](https://github.com/typescript-eslint/typescript-eslint/commit/1e29e69b289d61107a7de67592beae331ba50222))
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 
diff --git a/lerna.json b/lerna.json
index f7a5aa4c731..c6d458fa9fa 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "2.25.0",
+  "version": "2.26.0",
   "npmClient": "yarn",
   "useWorkspaces": true,
   "stream": true
diff --git a/packages/eslint-plugin-internal/CHANGELOG.md b/packages/eslint-plugin-internal/CHANGELOG.md
index 42a8af8be87..54cacab8889 100644
--- a/packages/eslint-plugin-internal/CHANGELOG.md
+++ b/packages/eslint-plugin-internal/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.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+**Note:** Version bump only for package @typescript-eslint/eslint-plugin-internal
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 **Note:** Version bump only for package @typescript-eslint/eslint-plugin-internal
diff --git a/packages/eslint-plugin-internal/package.json b/packages/eslint-plugin-internal/package.json
index afbc489b9ba..2a66b048492 100644
--- a/packages/eslint-plugin-internal/package.json
+++ b/packages/eslint-plugin-internal/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin-internal",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "private": true,
   "main": "dist/index.js",
   "scripts": {
@@ -12,6 +12,6 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.25.0"
+    "@typescript-eslint/experimental-utils": "2.26.0"
   }
 }
diff --git a/packages/eslint-plugin-tslint/CHANGELOG.md b/packages/eslint-plugin-tslint/CHANGELOG.md
index 38770408378..efd31d32624 100644
--- a/packages/eslint-plugin-tslint/CHANGELOG.md
+++ b/packages/eslint-plugin-tslint/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+
+### Features
+
+* **eslint-plugin-tslint:** support tslint 6 ([#1809](https://github.com/typescript-eslint/typescript-eslint/issues/1809)) ([7d963fd](https://github.com/typescript-eslint/typescript-eslint/commit/7d963fd846935acd91b7b0cd31c56a70a2b994d1))
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 
diff --git a/packages/eslint-plugin-tslint/package.json b/packages/eslint-plugin-tslint/package.json
index 1c422e8fa11..9a75ee89cd6 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": "2.25.0",
+  "version": "2.26.0",
   "main": "dist/index.js",
   "typings": "src/index.ts",
   "description": "TSLint wrapper plugin for ESLint",
@@ -31,7 +31,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.25.0",
+    "@typescript-eslint/experimental-utils": "2.26.0",
     "lodash": "^4.17.15"
   },
   "peerDependencies": {
@@ -41,6 +41,6 @@
   },
   "devDependencies": {
     "@types/lodash": "^4.14.149",
-    "@typescript-eslint/parser": "2.25.0"
+    "@typescript-eslint/parser": "2.26.0"
   }
 }
diff --git a/packages/eslint-plugin/CHANGELOG.md b/packages/eslint-plugin/CHANGELOG.md
index 074bd66c7ca..057df3312e5 100644
--- a/packages/eslint-plugin/CHANGELOG.md
+++ b/packages/eslint-plugin/CHANGELOG.md
@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+
+### Bug Fixes
+
+* **eslint-plugin:** [no-explicit-any] error with ignoreRestArgs ([#1796](https://github.com/typescript-eslint/typescript-eslint/issues/1796)) ([638d84d](https://github.com/typescript-eslint/typescript-eslint/commit/638d84ddd77d07117b3ec7c5431f3b0e44b1995d))
+* **eslint-plugin:** [no-unsafe-call] allow import expressions ([#1800](https://github.com/typescript-eslint/typescript-eslint/issues/1800)) ([4fa7107](https://github.com/typescript-eslint/typescript-eslint/commit/4fa710754ecc412b65ac3864fe0c7857c254ac1b))
+* **eslint-plugin:** [no-unsafe-return] error with <TS3.7 ([#1815](https://github.com/typescript-eslint/typescript-eslint/issues/1815)) ([f3160b4](https://github.com/typescript-eslint/typescript-eslint/commit/f3160b471f8247e157555b6cf5b40a1f6ccdc233))
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 
diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json
index cb725f5be6d..7689d700f4a 100644
--- a/packages/eslint-plugin/package.json
+++ b/packages/eslint-plugin/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "TypeScript plugin for ESLint",
   "keywords": [
     "eslint",
@@ -41,7 +41,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.25.0",
+    "@typescript-eslint/experimental-utils": "2.26.0",
     "functional-red-black-tree": "^1.0.1",
     "regexpp": "^3.0.0",
     "tsutils": "^3.17.1"
diff --git a/packages/experimental-utils/CHANGELOG.md b/packages/experimental-utils/CHANGELOG.md
index 6a731bc439b..00209a740b2 100644
--- a/packages/experimental-utils/CHANGELOG.md
+++ b/packages/experimental-utils/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+
+### Features
+
+* **typescript-estree:** add option to ignore certain folders from glob resolution ([#1802](https://github.com/typescript-eslint/typescript-eslint/issues/1802)) ([1e29e69](https://github.com/typescript-eslint/typescript-eslint/commit/1e29e69b289d61107a7de67592beae331ba50222))
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 
diff --git a/packages/experimental-utils/package.json b/packages/experimental-utils/package.json
index 52b42129a61..3e0b8a08c98 100644
--- a/packages/experimental-utils/package.json
+++ b/packages/experimental-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/experimental-utils",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "(Experimental) Utilities for working with TypeScript + ESLint together",
   "keywords": [
     "eslint",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@types/json-schema": "^7.0.3",
-    "@typescript-eslint/typescript-estree": "2.25.0",
+    "@typescript-eslint/typescript-estree": "2.26.0",
     "eslint-scope": "^5.0.0",
     "eslint-utils": "^2.0.0"
   },
diff --git a/packages/parser/CHANGELOG.md b/packages/parser/CHANGELOG.md
index ce9056408ac..3b604485e8d 100644
--- a/packages/parser/CHANGELOG.md
+++ b/packages/parser/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+
+### Features
+
+* **typescript-estree:** add option to ignore certain folders from glob resolution ([#1802](https://github.com/typescript-eslint/typescript-eslint/issues/1802)) ([1e29e69](https://github.com/typescript-eslint/typescript-eslint/commit/1e29e69b289d61107a7de67592beae331ba50222))
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 **Note:** Version bump only for package @typescript-eslint/parser
diff --git a/packages/parser/package.json b/packages/parser/package.json
index 33047db7557..b46b229c02e 100644
--- a/packages/parser/package.json
+++ b/packages/parser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/parser",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "An ESLint custom parser which leverages TypeScript ESTree",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
@@ -43,13 +43,13 @@
   },
   "dependencies": {
     "@types/eslint-visitor-keys": "^1.0.0",
-    "@typescript-eslint/experimental-utils": "2.25.0",
-    "@typescript-eslint/typescript-estree": "2.25.0",
+    "@typescript-eslint/experimental-utils": "2.26.0",
+    "@typescript-eslint/typescript-estree": "2.26.0",
     "eslint-visitor-keys": "^1.1.0"
   },
   "devDependencies": {
     "@types/glob": "^7.1.1",
-    "@typescript-eslint/shared-fixtures": "2.25.0",
+    "@typescript-eslint/shared-fixtures": "2.26.0",
     "glob": "*"
   },
   "peerDependenciesMeta": {
diff --git a/packages/shared-fixtures/CHANGELOG.md b/packages/shared-fixtures/CHANGELOG.md
index 535e49bbb58..f8ee7515974 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.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+**Note:** Version bump only for package @typescript-eslint/shared-fixtures
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 **Note:** Version bump only for package @typescript-eslint/shared-fixtures
diff --git a/packages/shared-fixtures/package.json b/packages/shared-fixtures/package.json
index 4775ceb0f14..b1e8d807285 100644
--- a/packages/shared-fixtures/package.json
+++ b/packages/shared-fixtures/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/shared-fixtures",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "private": true,
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
diff --git a/packages/typescript-estree/CHANGELOG.md b/packages/typescript-estree/CHANGELOG.md
index 91b7426e23d..c73e7476362 100644
--- a/packages/typescript-estree/CHANGELOG.md
+++ b/packages/typescript-estree/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
+
+
+### Features
+
+* **typescript-estree:** add option to ignore certain folders from glob resolution ([#1802](https://github.com/typescript-eslint/typescript-eslint/issues/1802)) ([1e29e69](https://github.com/typescript-eslint/typescript-eslint/commit/1e29e69b289d61107a7de67592beae331ba50222))
+
+
+
+
+
 # [2.25.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.24.0...v2.25.0) (2020-03-23)
 
 
diff --git a/packages/typescript-estree/package.json b/packages/typescript-estree/package.json
index 20ce7e15b5a..28214f3138c 100644
--- a/packages/typescript-estree/package.json
+++ b/packages/typescript-estree/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
@@ -58,7 +58,7 @@
     "@types/lodash": "^4.14.149",
     "@types/semver": "^6.2.0",
     "@types/tmp": "^0.1.0",
-    "@typescript-eslint/shared-fixtures": "2.25.0",
+    "@typescript-eslint/shared-fixtures": "2.26.0",
     "tmp": "^0.1.0",
     "typescript": "*"
   },

From 9b0023a4996ecdd7dfcb30abd1678091a78f3064 Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Mon, 30 Mar 2020 11:42:21 -0700
Subject: [PATCH 13/36] feat(eslint-plugin-internal): add
 plugin-test-formatting rule (#1821)

The strings that are used for eslint plugins will not be checked for formatting.
This can lead to diff noise as one contributor adjusts formatting, uses different quotes, etc.

This rule just enforces the following:
- all code samples are formatted with prettier
- all single line tests do not use backticks
- all multiline tests have:
  - no code on the first line
  - no code on the last line
  - the closing backtick indentation === property indentation
  - one of the following indentations:
    - no indentation at all
    - indentation of 1 + object indent

examples of enforced style:
```ts
ruleTester.run('foo', rule, {
  valid: [
    'const a = 1;',
    `
      const a = 1;
    `,
    `
const a = 1;
    `,
    {
      code: 'const a = 1;',
    },
    {
      code: `
        const a = 1;
      `,
    },
    {
      code: `
const a = 1;
      `,
    },
  ],
  invalid: [
    {
      code: 'const a = 1;',
    },
    {
      code: `
        const a = 1;
      `,
    },
    {
      code: `
const a = 1;
      `,
    },
  ],
});
```
---
 .prettierrc.json                              |   1 +
 packages/eslint-plugin-internal/package.json  |   3 +-
 .../eslint-plugin-internal/src/rules/index.ts |   2 +
 .../src/rules/plugin-test-formatting.ts       | 508 +++++++++++++++++
 .../rules/plugin-test-formatting.test.ts      | 518 ++++++++++++++++++
 packages/eslint-plugin/tests/RuleTester.ts    |  14 +-
 .../eslint-plugin/tools/generate-configs.ts   |   2 +-
 7 files changed, 1045 insertions(+), 3 deletions(-)
 create mode 100644 packages/eslint-plugin-internal/src/rules/plugin-test-formatting.ts
 create mode 100644 packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts

diff --git a/.prettierrc.json b/.prettierrc.json
index bf357fbbc08..a20502b7f06 100644
--- a/.prettierrc.json
+++ b/.prettierrc.json
@@ -1,3 +1,4 @@
 {
+  "singleQuote": true,
   "trailingComma": "all"
 }
diff --git a/packages/eslint-plugin-internal/package.json b/packages/eslint-plugin-internal/package.json
index 2a66b048492..8e250384428 100644
--- a/packages/eslint-plugin-internal/package.json
+++ b/packages/eslint-plugin-internal/package.json
@@ -12,6 +12,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.26.0"
+    "@typescript-eslint/experimental-utils": "2.26.0",
+    "prettier": "*"
   }
 }
diff --git a/packages/eslint-plugin-internal/src/rules/index.ts b/packages/eslint-plugin-internal/src/rules/index.ts
index f781e01e6df..eb8d8efe852 100644
--- a/packages/eslint-plugin-internal/src/rules/index.ts
+++ b/packages/eslint-plugin-internal/src/rules/index.ts
@@ -1,9 +1,11 @@
 import noTypescriptDefaultImport from './no-typescript-default-import';
 import noTypescriptEstreeImport from './no-typescript-estree-import';
+import pluginTestFormatting from './plugin-test-formatting';
 import preferASTTypesEnum from './prefer-ast-types-enum';
 
 export default {
   'no-typescript-default-import': noTypescriptDefaultImport,
   'no-typescript-estree-import': noTypescriptEstreeImport,
+  'plugin-test-formatting': pluginTestFormatting,
   'prefer-ast-types-enum': preferASTTypesEnum,
 };
diff --git a/packages/eslint-plugin-internal/src/rules/plugin-test-formatting.ts b/packages/eslint-plugin-internal/src/rules/plugin-test-formatting.ts
new file mode 100644
index 00000000000..bc26d9d9d9a
--- /dev/null
+++ b/packages/eslint-plugin-internal/src/rules/plugin-test-formatting.ts
@@ -0,0 +1,508 @@
+import {
+  AST_NODE_TYPES,
+  TSESTree,
+} from '@typescript-eslint/experimental-utils';
+import { format, resolveConfig } from 'prettier';
+import { createRule } from '../util';
+
+/*
+The strings that are used for eslint plugins will not be checked for formatting.
+This can lead to diff noise as one contributor adjusts formatting, uses different quotes, etc.
+
+This rule just enforces the following:
+- all code samples are formatted with prettier
+- all single line tests do not use backticks
+- all multiline tests have:
+  - no code on the first line
+  - no code on the last line
+  - the closing backtick indentation === property indentation
+  - one of the following indentations:
+    - no indentation at all
+    - indentation of 1 + object indent
+
+eg:
+[
+  'const a = 1;',
+  `
+const a = 1;
+  `,
+  `
+    const a = 1;
+  `,
+  {
+    code: 'const a = 1',
+  }
+  {
+    code: `
+const a = 1;
+    `,
+  }
+  {
+    code: `
+      const a = 1;
+    `,
+  }
+]
+*/
+
+const prettierConfig = resolveConfig.sync(__dirname) ?? {};
+const START_OF_LINE_WHITESPACE_MATCHER = /^([ ]*)/;
+const BACKTICK_REGEX = /`/g;
+const TEMPLATE_EXPR_OPENER = /\$\{/g;
+
+function getExpectedIndentForNode(
+  node: TSESTree.Node,
+  sourceCodeLines: string[],
+): number {
+  const lineIdx = node.loc.start.line - 1;
+  const indent = START_OF_LINE_WHITESPACE_MATCHER.exec(
+    sourceCodeLines[lineIdx],
+  )![1];
+  return indent.length;
+}
+function doIndent(line: string, indent: number): string {
+  for (let i = 0; i < indent; i += 1) {
+    line = ' ' + line;
+  }
+  return line;
+}
+
+function getQuote(code: string): "'" | '"' | null {
+  const hasSingleQuote = code.includes("'");
+  const hasDoubleQuote = code.includes('"');
+  if (hasSingleQuote && hasDoubleQuote) {
+    // be lazy and make them fix and escape the quotes manually
+    return null;
+  }
+
+  return hasSingleQuote ? '"' : "'";
+}
+
+function escapeTemplateString(code: string): string {
+  let fixed = code;
+  fixed = fixed.replace(BACKTICK_REGEX, '\\`');
+  fixed = fixed.replace(TEMPLATE_EXPR_OPENER, '\\${');
+  return fixed;
+}
+
+type Options = [
+  {
+    // This option exists so that rules like type-annotation-spacing can exist without every test needing a prettier-ignore
+    formatWithPrettier?: boolean;
+  },
+];
+
+type MessageIds =
+  | 'invalidFormatting'
+  | 'invalidFormattingErrorTest'
+  | 'singleLineQuotes'
+  | 'templateLiteralEmptyEnds'
+  | 'templateLiteralLastLineIndent'
+  | 'templateStringRequiresIndent'
+  | 'templateStringMinimumIndent'
+  | 'prettierException';
+
+export default createRule<Options, MessageIds>({
+  name: 'plugin-test-formatting',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: `Enforces that eslint-plugin test snippets are correctly formatted`,
+      category: 'Stylistic Issues',
+      recommended: 'error',
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          formatWithPrettier: {
+            type: 'boolean',
+          },
+        },
+      },
+    ],
+    messages: {
+      invalidFormatting:
+        'This snippet should be formatted correctly. Use the fixer to format the code.',
+      invalidFormattingErrorTest:
+        'This snippet should be formatted correctly. Use the fixer to format the code. Note that the automated fixer may break your test locations.',
+      singleLineQuotes: 'Use quotes (\' or ") for single line tests.',
+      templateLiteralEmptyEnds:
+        'Template literals must start and end with an empty line.',
+      templateLiteralLastLineIndent:
+        'The closing line of the template literal must be indented to align with its parent.',
+      templateStringRequiresIndent:
+        'Test code should either have no indent, or be indented {{indent}} spaces.',
+      templateStringMinimumIndent:
+        'Test code should be indented at least {{indent}} spaces.',
+      prettierException:
+        'Prettier was unable to format this snippet: {{message}}',
+    },
+  },
+  defaultOptions: [
+    {
+      formatWithPrettier: true,
+    },
+  ],
+  create(context, [{ formatWithPrettier }]) {
+    const sourceCode = context.getSourceCode();
+
+    function prettierFormat(
+      code: string,
+      location: TSESTree.Node,
+    ): string | null {
+      if (formatWithPrettier === false) {
+        return null;
+      }
+
+      try {
+        return format(code, {
+          ...prettierConfig,
+          parser: 'typescript',
+        }).trimRight(); // prettier will insert a new line at the end of the code
+      } catch (ex) {
+        // adapted from https://github.com/prettier/eslint-plugin-prettier/blob/185b1064d3dd674538456fb2fad97fbfcde49e0d/eslint-plugin-prettier.js#L242-L257
+        if (!(ex instanceof SyntaxError)) {
+          throw ex;
+        }
+        const err = ex as Error & {
+          codeFrame: string;
+          loc?: unknown;
+        };
+
+        let message = err.message;
+
+        if (err.codeFrame) {
+          message = message.replace(`\n${err.codeFrame}`, '');
+        }
+        if (err.loc) {
+          message = message.replace(/ \(\d+:\d+\)$/, '');
+        }
+
+        context.report({
+          node: location,
+          messageId: 'prettierException',
+          data: {
+            message,
+          },
+        });
+        return null;
+      }
+    }
+
+    function checkExpression(node: TSESTree.Node, isErrorTest: boolean): void {
+      switch (node.type) {
+        case AST_NODE_TYPES.Literal:
+          checkLiteral(node, isErrorTest);
+          break;
+
+        case AST_NODE_TYPES.TemplateLiteral:
+          checkTemplateLiteral(node, isErrorTest);
+          break;
+
+        case AST_NODE_TYPES.TaggedTemplateExpression:
+          checkTaggedTemplateExpression(node, isErrorTest);
+          break;
+
+        case AST_NODE_TYPES.CallExpression:
+          checkCallExpression(node, isErrorTest);
+          break;
+      }
+    }
+
+    function checkLiteral(
+      literal: TSESTree.Literal,
+      isErrorTest: boolean,
+      quoteIn?: string,
+    ): void {
+      if (typeof literal.value === 'string') {
+        const output = prettierFormat(literal.value, literal);
+        if (output && output !== literal.value) {
+          context.report({
+            node: literal,
+            messageId: isErrorTest
+              ? 'invalidFormattingErrorTest'
+              : 'invalidFormatting',
+            fix(fixer) {
+              if (output.includes('\n')) {
+                // formatted string is multiline, then have to use backticks
+                return fixer.replaceText(
+                  literal,
+                  `\`${escapeTemplateString(output)}\``,
+                );
+              }
+
+              const quote = quoteIn ?? getQuote(output);
+              if (quote == null) {
+                return null;
+              }
+
+              return fixer.replaceText(literal, `${quote}${output}${quote}`);
+            },
+          });
+        }
+      }
+    }
+
+    function checkTemplateLiteral(
+      literal: TSESTree.TemplateLiteral,
+      isErrorTest: boolean,
+      isNoFormatTagged = false,
+    ): void {
+      if (literal.quasis.length > 1) {
+        // ignore template literals with ${expressions} for simplicity
+        return;
+      }
+
+      const text = literal.quasis[0].value.cooked;
+
+      if (literal.loc.end.line === literal.loc.start.line) {
+        // don't use template strings for single line tests
+        return context.report({
+          node: literal,
+          messageId: 'singleLineQuotes',
+          fix(fixer) {
+            const quote = getQuote(text);
+            if (quote == null) {
+              return null;
+            }
+
+            return [
+              fixer.replaceTextRange(
+                [literal.range[0], literal.range[0] + 1],
+                quote,
+              ),
+              fixer.replaceTextRange(
+                [literal.range[1] - 1, literal.range[1]],
+                quote,
+              ),
+            ];
+          },
+        });
+      }
+
+      const lines = text.split('\n');
+      const lastLine = lines[lines.length - 1];
+      // prettier will trim out the end of line on save, but eslint will check before then
+      const isStartEmpty = lines[0].trimRight() === '';
+      // last line can be indented
+      const isEndEmpty = lastLine.trimLeft() === '';
+      if (!isStartEmpty || !isEndEmpty) {
+        // multiline template strings must have an empty first/last line
+        return context.report({
+          node: literal,
+          messageId: 'templateLiteralEmptyEnds',
+          *fix(fixer) {
+            if (!isStartEmpty) {
+              yield fixer.replaceTextRange(
+                [literal.range[0], literal.range[0] + 1],
+                '`\n',
+              );
+            }
+
+            if (!isEndEmpty) {
+              yield fixer.replaceTextRange(
+                [literal.range[1] - 1, literal.range[1]],
+                '\n`',
+              );
+            }
+          },
+        });
+      }
+
+      const parentIndent = getExpectedIndentForNode(literal, sourceCode.lines);
+      if (lastLine.length !== parentIndent) {
+        return context.report({
+          node: literal,
+          messageId: 'templateLiteralLastLineIndent',
+          fix(fixer) {
+            return fixer.replaceTextRange(
+              [literal.range[1] - lastLine.length - 1, literal.range[1]],
+              doIndent('`', parentIndent),
+            );
+          },
+        });
+      }
+
+      // remove the empty lines
+      lines.pop();
+      lines.shift();
+
+      // +2 because we expect the string contents are indented one level
+      const expectedIndent = parentIndent + 2;
+
+      const firstLineIndent = START_OF_LINE_WHITESPACE_MATCHER.exec(
+        lines[0],
+      )![1];
+      const requiresIndent = firstLineIndent.length > 0;
+      if (requiresIndent) {
+        if (firstLineIndent.length !== expectedIndent) {
+          return context.report({
+            node: literal,
+            messageId: 'templateStringRequiresIndent',
+            data: {
+              indent: expectedIndent,
+            },
+          });
+        }
+
+        // quick-and-dirty validation that lines are roughly indented correctly
+        for (const line of lines) {
+          if (line.length === 0) {
+            // empty lines are valid
+            continue;
+          }
+
+          const matches = START_OF_LINE_WHITESPACE_MATCHER.exec(line)!;
+
+          const indent = matches[1];
+          if (indent.length < expectedIndent) {
+            return context.report({
+              node: literal,
+              messageId: 'templateStringMinimumIndent',
+              data: {
+                indent: expectedIndent,
+              },
+            });
+          }
+        }
+
+        // trim the lines to remove expectedIndent characters from the start
+        // this makes it easier to check formatting
+        for (let i = 0; i < lines.length; i += 1) {
+          lines[i] = lines[i].substring(expectedIndent);
+        }
+      }
+
+      if (isNoFormatTagged) {
+        return;
+      }
+
+      const code = lines.join('\n');
+      const formatted = prettierFormat(code, literal);
+      if (formatted && formatted !== code) {
+        const formattedIndented = requiresIndent
+          ? formatted
+              .split('\n')
+              .map(l => doIndent(l, expectedIndent))
+              .join('\n')
+          : formatted;
+
+        return context.report({
+          node: literal,
+          messageId: isErrorTest
+            ? 'invalidFormattingErrorTest'
+            : 'invalidFormatting',
+          fix(fixer) {
+            return fixer.replaceText(
+              literal,
+              `\`\n${escapeTemplateString(formattedIndented)}\n${doIndent(
+                '',
+                parentIndent,
+              )}\``,
+            );
+          },
+        });
+      }
+    }
+
+    function isNoFormatTemplateTag(tag: TSESTree.Expression): boolean {
+      return tag.type === AST_NODE_TYPES.Identifier && tag.name === 'noFormat';
+    }
+
+    function checkTaggedTemplateExpression(
+      expr: TSESTree.TaggedTemplateExpression,
+      isErrorTest: boolean,
+    ): void {
+      if (!isNoFormatTemplateTag(expr.tag)) {
+        return;
+      }
+
+      if (expr.loc.start.line === expr.loc.end.line) {
+        // all we do on single line test cases is check format, but there's no formatting to do
+        return;
+      }
+
+      checkTemplateLiteral(
+        expr.quasi,
+        isErrorTest,
+        isNoFormatTemplateTag(expr.tag),
+      );
+    }
+
+    function checkCallExpression(
+      callExpr: TSESTree.CallExpression,
+      isErrorTest: boolean,
+    ): void {
+      if (callExpr.callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return;
+      }
+      const memberExpr = callExpr.callee;
+      // handle cases like 'aa'.trimRight and `aa`.trimRight()
+      checkExpression(memberExpr.object, isErrorTest);
+    }
+
+    function checkInvalidTest(
+      test: TSESTree.ObjectExpression,
+      isErrorTest = true,
+    ): void {
+      for (const prop of test.properties) {
+        if (
+          prop.type !== AST_NODE_TYPES.Property ||
+          prop.computed ||
+          prop.key.type !== AST_NODE_TYPES.Identifier
+        ) {
+          continue;
+        }
+
+        if (prop.key.name === 'code' || prop.key.name === 'output') {
+          checkExpression(prop.value, isErrorTest);
+        }
+      }
+    }
+
+    function checkValidTest(tests: TSESTree.ArrayExpression): void {
+      for (const test of tests.elements) {
+        switch (test.type) {
+          case AST_NODE_TYPES.ObjectExpression:
+            // delegate object-style tests to the invalid checker
+            checkInvalidTest(test, false);
+            break;
+
+          default:
+            checkExpression(test, false);
+            break;
+        }
+      }
+    }
+
+    const invalidTestsSelectorPath = [
+      AST_NODE_TYPES.CallExpression,
+      AST_NODE_TYPES.ObjectExpression,
+      'Property[key.name = "invalid"]',
+      AST_NODE_TYPES.ArrayExpression,
+      AST_NODE_TYPES.ObjectExpression,
+    ];
+
+    return {
+      // valid
+      'CallExpression > ObjectExpression > Property[key.name = "valid"] > ArrayExpression': checkValidTest,
+      // invalid - errors
+      [invalidTestsSelectorPath.join(' > ')]: checkInvalidTest,
+      // invalid - suggestions
+      [[
+        ...invalidTestsSelectorPath,
+        'Property[key.name = "errors"]',
+        AST_NODE_TYPES.ArrayExpression,
+        AST_NODE_TYPES.ObjectExpression,
+        'Property[key.name = "suggestions"]',
+        AST_NODE_TYPES.ArrayExpression,
+        AST_NODE_TYPES.ObjectExpression,
+      ].join(' > ')]: checkInvalidTest,
+      // special case for our batchedSingleLineTests utility
+      'CallExpression[callee.name = "batchedSingleLineTests"] > ObjectExpression': checkInvalidTest,
+    };
+  },
+});
diff --git a/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts b/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
new file mode 100644
index 00000000000..8d7e0b2c1d8
--- /dev/null
+++ b/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
@@ -0,0 +1,518 @@
+import rule from '../../src/rules/plugin-test-formatting';
+import { RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    sourceType: 'module',
+  },
+});
+
+const CODE_INDENT = '        ';
+const PARENT_INDENT = '      ';
+function wrap(strings: TemplateStringsArray, ...keys: string[]): string {
+  const lastIndex = strings.length - 1;
+  const code =
+    strings.slice(0, lastIndex).reduce((p, s, i) => p + s + keys[i], '') +
+    strings[lastIndex];
+  return `
+ruleTester.run({
+  valid: [
+    {
+      code: ${code},
+    },
+  ],
+});
+  `;
+}
+function wrapWithOutput(
+  strings: TemplateStringsArray,
+  ...keys: string[]
+): string {
+  const lastIndex = strings.length - 1;
+  const code =
+    strings.slice(0, lastIndex).reduce((p, s, i) => p + s + keys[i], '') +
+    strings[lastIndex];
+  return `
+ruleTester.run({
+  invalid: [
+    {
+      code: ${code},
+      output: ${code},
+    },
+  ],
+});
+  `;
+}
+
+ruleTester.run('plugin-test-formatting', rule, {
+  valid: [
+    // sanity check for valid tests non-object style
+    `
+ruleTester.run({
+  valid: [
+    'const a = 1;',
+    \`
+      const a = 1;
+    \`,
+    \`
+const a = 1;
+    \`,
+    noFormat\`const x=1;\`,
+  ],
+});
+    `,
+    wrap`'const a = 1;'`,
+    wrap`\`
+${CODE_INDENT}const a = 1;
+${PARENT_INDENT}\``,
+    wrap`\`
+const a = 1;
+${PARENT_INDENT}\``,
+    wrap`noFormat\`const a = 1;\``,
+    // sanity check suggestion validation
+    `
+      ruleTester.run({
+        invalid: [
+          {
+            code: 'const a = 1;',
+            output: 'const a = 1;',
+            errors: [
+              {
+                messageId: 'foo',
+                suggestions: [
+                  {
+                    messageId: 'bar',
+                    output: 'const a = 1;',
+                  },
+                ],
+              }
+            ]
+          },
+          {
+            code: \`
+              const a = 1;
+            \`,
+            output: \`
+              const a = 1;
+            \`,
+            errors: [
+              {
+                messageId: 'foo',
+                suggestions: [
+                  {
+                    messageId: 'bar',
+                    output: \`
+                      const a = 1;
+                    \`,
+                  },
+                ],
+              }
+            ]
+          },
+          {
+            code: \`
+const a = 1;
+            \`,
+            output: \`
+const a = 1;
+            \`,
+            errors: [
+              {
+                messageId: 'foo',
+                suggestions: [
+                  {
+                    messageId: 'bar',
+                    output: \`
+const a = 1;
+                    \`,
+                  },
+                ],
+              }
+            ]
+          },
+        ],
+      });
+    `,
+
+    // test the only option
+    {
+      code: wrap`'const x=1;'`,
+      options: [
+        {
+          formatWithPrettier: false,
+        },
+      ],
+    },
+
+    // empty linems are valid when everything else is indented
+    wrap`\`
+${CODE_INDENT}const a = 1;
+
+${CODE_INDENT}const b = 1;
+${PARENT_INDENT}\``,
+  ],
+  invalid: [
+    // Literal
+    {
+      code: wrap`'const a=1;'`,
+      output: wrap`'const a = 1;'`,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+    {
+      code: wrap`'const a="1";'`,
+      output: wrap`"const a = '1';"`,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+    {
+      code: wrap`"const a='1';"`,
+      output: wrap`"const a = '1';"`,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+    {
+      code: wrap`'for (const x of y) {}'`,
+      output: wrap`\`for (const x of y) {
+}\``,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+    {
+      code: wrap`'for (const x of \`asdf\`) {}'`,
+      // make sure it escapes the backticks
+      output: wrap`\`for (const x of \\\`asdf\\\`) {
+}\``,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+    // TemplateLiteral
+    // singleLineQuotes
+    {
+      code: wrap`\`const a = 1;\``,
+      output: wrap`'const a = 1;'`,
+      errors: [
+        {
+          messageId: 'singleLineQuotes',
+        },
+      ],
+    },
+    {
+      code: wrap`\`const a = '1'\``,
+      output: wrap`"const a = '1'"`,
+      errors: [
+        {
+          messageId: 'singleLineQuotes',
+        },
+      ],
+    },
+    {
+      code: wrap`\`const a = "1";\``,
+      output: wrap`'const a = "1";'`,
+      errors: [
+        {
+          messageId: 'singleLineQuotes',
+        },
+      ],
+    },
+    // templateLiteralEmptyEnds
+    {
+      code: wrap`\`const a = "1";
+${PARENT_INDENT}\``,
+      output: wrap`\`
+const a = "1";
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+      ],
+    },
+    {
+      code: wrap`\`
+${CODE_INDENT}const a = "1";\``,
+      output: wrap`\`
+${CODE_INDENT}const a = "1";
+\``,
+      errors: [
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+      ],
+    },
+    {
+      code: wrap`\`const a = "1";
+${CODE_INDENT}const b = "2";\``,
+      output: wrap`\`
+const a = "1";
+${CODE_INDENT}const b = "2";
+\``,
+      errors: [
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+      ],
+    },
+    // templateLiteralLastLineIndent
+    {
+      code: wrap`\`
+${CODE_INDENT}const a = "1";
+\``,
+      output: wrap`\`
+${CODE_INDENT}const a = "1";
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'templateLiteralLastLineIndent',
+        },
+      ],
+    },
+    {
+      code: wrap`\`
+${CODE_INDENT}const a = "1";
+                      \``,
+      output: wrap`\`
+${CODE_INDENT}const a = "1";
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'templateLiteralLastLineIndent',
+        },
+      ],
+    },
+    // templateStringRequiresIndent
+    {
+      code: wrap`\`
+  const a = "1";
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'templateStringRequiresIndent',
+          data: {
+            indent: CODE_INDENT.length,
+          },
+        },
+      ],
+    },
+    {
+      code: `
+ruleTester.run({
+  valid: [
+    \`
+    const a = "1";
+    \`,
+  ],
+});
+      `,
+      errors: [
+        {
+          messageId: 'templateStringRequiresIndent',
+          data: {
+            indent: 6,
+          },
+        },
+      ],
+    },
+    // templateStringMinimumIndent
+    {
+      code: wrap`\`
+${CODE_INDENT}const a = "1";
+  const b = "2";
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'templateStringMinimumIndent',
+          data: {
+            indent: CODE_INDENT.length,
+          },
+        },
+      ],
+    },
+    // invalidFormatting
+    {
+      code: wrap`\`
+${CODE_INDENT}const a="1";
+${CODE_INDENT}          const b    =   "2";
+${PARENT_INDENT}\``,
+      output: wrap`\`
+${CODE_INDENT}const a = '1';
+${CODE_INDENT}const b = '2';
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+    {
+      code: wrap`\`
+${CODE_INDENT}const a=\\\`\\\${a}\\\`;
+${PARENT_INDENT}\``,
+      // make sure it escapes backticks
+      output: wrap`\`
+${CODE_INDENT}const a = \\\`\\\${a}\\\`;
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+
+    // sanity check that it runs on both output and code properties
+    {
+      code: wrapWithOutput`\`
+${CODE_INDENT}const a="1";
+${CODE_INDENT}          const b    =   "2";
+${PARENT_INDENT}\``,
+      output: wrapWithOutput`\`
+${CODE_INDENT}const a = '1';
+${CODE_INDENT}const b = '2';
+${PARENT_INDENT}\``,
+      errors: [
+        {
+          messageId: 'invalidFormattingErrorTest',
+        },
+        {
+          messageId: 'invalidFormattingErrorTest',
+        },
+      ],
+    },
+
+    // sanity check that it handles suggestion output
+    {
+      code: `
+ruleTester.run({
+  valid: [],
+  invalid: [
+    {
+      code: 'const x=1;',
+      errors: [
+        {
+          messageId: 'foo',
+          suggestions: [
+            {
+              messageId: 'bar',
+              output: 'const x=1;',
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});
+      `,
+      errors: [
+        {
+          messageId: 'invalidFormattingErrorTest',
+        },
+        {
+          messageId: 'invalidFormattingErrorTest',
+        },
+      ],
+    },
+
+    // sanity check that it runs on all tests
+    {
+      code: `
+ruleTester.run({
+  valid: [
+    {
+      code: \`foo\`,
+    },
+    {
+      code: \`foo
+\`,
+    },
+    {
+      code: \`
+      foo\`,
+    },
+  ],
+  invalid: [
+    {
+      code: \`foo\`,
+    },
+    {
+      code: \`foo
+\`,
+    },
+    {
+      code: \`
+      foo\`,
+    },
+  ],
+});
+      `,
+      errors: [
+        {
+          messageId: 'singleLineQuotes',
+        },
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+        {
+          messageId: 'singleLineQuotes',
+        },
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+      ],
+    },
+
+    // handles prettier errors
+    {
+      code: wrap`'const x = ";'`,
+      errors: [
+        {
+          messageId: 'prettierException',
+          data: {
+            message: 'Unterminated string literal.',
+          },
+        },
+      ],
+    },
+
+    // checks tests with .trimRight calls
+    {
+      code: wrap`'const a=1;'.trimRight()`,
+      output: wrap`'const a = 1;'.trimRight()`,
+      errors: [
+        {
+          messageId: 'invalidFormatting',
+        },
+      ],
+    },
+    {
+      code: wrap`\`const a = "1";
+${CODE_INDENT}\`.trimRight()`,
+      errors: [
+        {
+          messageId: 'templateLiteralEmptyEnds',
+        },
+      ],
+    },
+  ],
+});
diff --git a/packages/eslint-plugin/tests/RuleTester.ts b/packages/eslint-plugin/tests/RuleTester.ts
index c650c83449c..1774200db32 100644
--- a/packages/eslint-plugin/tests/RuleTester.ts
+++ b/packages/eslint-plugin/tests/RuleTester.ts
@@ -89,4 +89,16 @@ afterAll(() => {
   clearCaches();
 });
 
-export { RuleTester, getFixturesRootDir, batchedSingleLineTests };
+/**
+ * Simple no-op tag to mark code samples as "should not format with prettier"
+ *   for the internal/plugin-test-formatting lint rule
+ */
+function noFormat(strings: TemplateStringsArray, ...keys: string[]): string {
+  const lastIndex = strings.length - 1;
+  return (
+    strings.slice(0, lastIndex).reduce((p, s, i) => p + s + keys[i], '') +
+    strings[lastIndex]
+  );
+}
+
+export { batchedSingleLineTests, getFixturesRootDir, noFormat, RuleTester };
diff --git a/packages/eslint-plugin/tools/generate-configs.ts b/packages/eslint-plugin/tools/generate-configs.ts
index d35fd7362bc..e9d2a8be762 100644
--- a/packages/eslint-plugin/tools/generate-configs.ts
+++ b/packages/eslint-plugin/tools/generate-configs.ts
@@ -5,7 +5,7 @@ import path from 'path';
 import { format, resolveConfig } from 'prettier';
 import rules from '../src/rules';
 
-const prettierConfig = resolveConfig(__dirname);
+const prettierConfig = resolveConfig.sync(__dirname);
 
 interface LinterConfigRules {
   [name: string]:

From 8ec53a3579fcb59cdffea0c60fbb755d056f4c8a Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Mon, 30 Mar 2020 17:04:10 -0700
Subject: [PATCH 14/36] fix(eslint-plugin): [no-unsafe-call] fix incorrect
 selector (#1826)

---
 packages/eslint-plugin/src/rules/no-unsafe-call.ts        | 2 +-
 packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/src/rules/no-unsafe-call.ts b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
index 13cabc87d92..66f66448c28 100644
--- a/packages/eslint-plugin/src/rules/no-unsafe-call.ts
+++ b/packages/eslint-plugin/src/rules/no-unsafe-call.ts
@@ -41,7 +41,7 @@ export default util.createRule<[], MessageIds>({
     }
 
     return {
-      ':matches(CallExpression, OptionalCallExpression) > :not(Import)'(
+      ':matches(CallExpression, OptionalCallExpression) > :not(Import).callee'(
         node: Exclude<TSESTree.LeftHandSideExpression, TSESTree.Import>,
       ): void {
         checkCall(node, node, 'unsafeCall');
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
index a51273c9b9c..bc7b6c7d086 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
@@ -21,6 +21,11 @@ ruleTester.run('no-unsafe-call', rule, {
     'new Map()',
     'String.raw`foo`',
     'const x = import("./foo");',
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1825
+    `
+      let foo: any = 23;
+      String(foo); // ERROR: Unsafe call of an any typed value
+    `,
   ],
   invalid: [
     ...batchedSingleLineTests({

From 9642d9dce693befac89a4e9d8bf8dd18f4361e2a Mon Sep 17 00:00:00 2001
From: Anix <anik220798@gmail.com>
Date: Tue, 31 Mar 2020 09:53:23 +0530
Subject: [PATCH 15/36] fix(eslint-plugin): [require-await] handle async
 generators (#1782)

Co-authored-by: Brad Zacher <brad.zacher@gmail.com>
---
 .../eslint-plugin/src/rules/require-await.ts  |  38 ++-
 .../tests/rules/require-await.test.ts         | 244 +++++++++++++-----
 2 files changed, 217 insertions(+), 65 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/require-await.ts b/packages/eslint-plugin/src/rules/require-await.ts
index e7b6a5f5959..99c455cd0f6 100644
--- a/packages/eslint-plugin/src/rules/require-await.ts
+++ b/packages/eslint-plugin/src/rules/require-await.ts
@@ -11,6 +11,8 @@ interface ScopeInfo {
   upper: ScopeInfo | null;
   hasAwait: boolean;
   hasAsync: boolean;
+  isGen: boolean;
+  isAsyncYield: boolean;
 }
 type FunctionNode =
   | TSESTree.FunctionDeclaration
@@ -49,6 +51,8 @@ export default util.createRule({
         upper: scopeInfo,
         hasAwait: false,
         hasAsync: node.async,
+        isGen: node.generator || false,
+        isAsyncYield: false,
       };
     }
 
@@ -62,7 +66,12 @@ export default util.createRule({
         return;
       }
 
-      if (node.async && !scopeInfo.hasAwait && !isEmptyFunction(node)) {
+      if (
+        node.async &&
+        !scopeInfo.hasAwait &&
+        !isEmptyFunction(node) &&
+        !(scopeInfo.isGen && scopeInfo.isAsyncYield)
+      ) {
         context.report({
           node,
           loc: getFunctionHeadLoc(node, sourceCode),
@@ -92,10 +101,34 @@ export default util.createRule({
       if (!scopeInfo) {
         return;
       }
-
       scopeInfo.hasAwait = true;
     }
 
+    /**
+     * mark `scopeInfo.isAsyncYield` to `true` if its a generator
+     * function and the delegate is `true`
+     */
+    function markAsHasDelegateGen(node: TSESTree.YieldExpression): void {
+      if (!scopeInfo || !scopeInfo.isGen || !node.argument) {
+        return;
+      }
+
+      if (node?.argument?.type === AST_NODE_TYPES.Literal) {
+        // making this `false` as for literals we don't need to check the definition
+        // eg : async function* run() { yield* 1 }
+        scopeInfo.isAsyncYield = false;
+      }
+
+      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node?.argument);
+      const type = checker.getTypeAtLocation(tsNode);
+      const symbol = type.getSymbol();
+
+      // async function* test1() {yield* asyncGenerator() }
+      if (symbol?.getName() === 'AsyncGenerator') {
+        scopeInfo.isAsyncYield = true;
+      }
+    }
+
     return {
       FunctionDeclaration: enterFunction,
       FunctionExpression: enterFunction,
@@ -106,6 +139,7 @@ export default util.createRule({
 
       AwaitExpression: markAsHasAwait,
       'ForOfStatement[await = true]': markAsHasAwait,
+      'YieldExpression[delegate = true]': markAsHasDelegateGen,
 
       // check body-less async arrow function.
       // ignore `async () => await foo` because it's obviously correct
diff --git a/packages/eslint-plugin/tests/rules/require-await.test.ts b/packages/eslint-plugin/tests/rules/require-await.test.ts
index 66db5497980..caea93fbfb9 100644
--- a/packages/eslint-plugin/tests/rules/require-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/require-await.test.ts
@@ -16,102 +16,130 @@ ruleTester.run('require-await', rule, {
   valid: [
     // Non-async function declaration
     `function numberOne(): number {
-      return 1;
-    }`,
+          return 1;
+        }`,
     // Non-async function expression
     `const numberOne = function(): number {
-      return 1;
-    }`,
+          return 1;
+        }`,
     // Non-async arrow function expression (concise-body)
     `const numberOne = (): number => 1;`,
     // Non-async arrow function expression (block-body)
     `const numberOne = (): number => {
-      return 1;
-    };`,
+          return 1;
+        };`,
     // Non-async function that returns a promise
     // https://github.com/typescript-eslint/typescript-eslint/issues/1226
     `
-function delay() {
-  return Promise.resolve();
-}
-    `,
+    function delay() {
+      return Promise.resolve();
+    }
+        `,
     `
-const delay = () => {
-  return Promise.resolve();
-}
-    `,
+    const delay = () => {
+      return Promise.resolve();
+    }
+        `,
     `const delay = () => Promise.resolve();`,
     // Async function declaration with await
     `async function numberOne(): Promise<number> {
-      return await 1;
-    }`,
+          return await 1;
+        }`,
     // Async function expression with await
     `const numberOne = async function(): Promise<number> {
-      return await 1;
-    }`,
+          return await 1;
+        }`,
     // Async arrow function expression with await (concise-body)
     `const numberOne = async (): Promise<number> => await 1;`,
     // Async arrow function expression with await (block-body)
     `const numberOne = async (): Promise<number> => {
-      return await 1;
-    };`,
+          return await 1;
+        };`,
     // Async function declaration with promise return
     `async function numberOne(): Promise<number> {
-      return Promise.resolve(1);
-    }`,
+          return Promise.resolve(1);
+        }`,
     // Async function expression with promise return
     `const numberOne = async function(): Promise<number> {
-      return Promise.resolve(1);
-    }`,
+          return Promise.resolve(1);
+        }`,
     // Async arrow function with promise return (concise-body)
     `const numberOne = async (): Promise<number> => Promise.resolve(1);`,
     // Async arrow function with promise return (block-body)
     `const numberOne = async (): Promise<number> => {
-      return Promise.resolve(1);
-    };`,
+          return Promise.resolve(1);
+        };`,
     // Async function declaration with async function return
     `async function numberOne(): Promise<number> {
-      return getAsyncNumber(1);
-    }
-    async function getAsyncNumber(x: number): Promise<number> {
-      return Promise.resolve(x);
-    }`,
+          return getAsyncNumber(1);
+        }
+        async function getAsyncNumber(x: number): Promise<number> {
+          return Promise.resolve(x);
+        }`,
     // Async function expression with async function return
     `const numberOne = async function(): Promise<number> {
-      return getAsyncNumber(1);
-    }
-    const getAsyncNumber = async function(x: number): Promise<number> {
-      return Promise.resolve(x);
-    }`,
+          return getAsyncNumber(1);
+        }
+        const getAsyncNumber = async function(x: number): Promise<number> {
+          return Promise.resolve(x);
+        }`,
     // Async arrow function with async function return (concise-body)
     `const numberOne = async (): Promise<number> => getAsyncNumber(1);
-    const getAsyncNumber = async function(x: number): Promise<number> {
-      return Promise.resolve(x);
-    }`,
+        const getAsyncNumber = async function(x: number): Promise<number> {
+          return Promise.resolve(x);
+        }`,
     // Async arrow function with async function return (block-body)
     `const numberOne = async (): Promise<number> => {
-      return getAsyncNumber(1);
-    };
-    const getAsyncNumber = async function(x: number): Promise<number> {
-      return Promise.resolve(x);
-    }`,
+          return getAsyncNumber(1);
+        };
+        const getAsyncNumber = async function(x: number): Promise<number> {
+          return Promise.resolve(x);
+        }`,
     // https://github.com/typescript-eslint/typescript-eslint/issues/1188
     `
-async function testFunction(): Promise<void> {
-  await Promise.all([1, 2, 3].map(
-    // this should not trigger an error on the parent function
-    async value => Promise.resolve(value)
-  ))
-}
+    async function testFunction(): Promise<void> {
+      await Promise.all([1, 2, 3].map(
+        // this should not trigger an error on the parent function
+        async value => Promise.resolve(value)
+      ))
+    }
+        `,
+    `
+        async function* run() {
+          await new Promise(resolve => setTimeout(resolve, 100));
+          yield 'Hello';
+          console.log('World');
+        }
+        `,
+    'async function* run() { }',
+    'async function* asyncGenerator() { await Promise.resolve(); yield 1 }',
+    'function* test6() { yield* syncGenerator() }',
+    'function* test8() { yield syncGenerator() }',
+    'function* syncGenerator() { yield 1 }',
+    `
+    async function* asyncGenerator() {
+      await Promise.resolve()
+      yield 1
+    }
+    async function* test1() {yield* asyncGenerator() }
     `,
+    `async function* foo() {
+            await Promise.resolve()
+            yield 1
+          }
+          async function* bar() {
+            yield* foo()
+          }`,
+    'const foo : () => void = async function *(){}',
+    'async function* foo() : Promise<string> { return new Promise((res) => res(`hello`)) }',
   ],
 
   invalid: [
     {
       // Async function declaration with no await
       code: `async function numberOne(): Promise<number> {
-        return 1;
-      }`,
+            return 1;
+          }`,
       errors: [
         {
           messageId: 'missingAwait',
@@ -124,8 +152,8 @@ async function testFunction(): Promise<void> {
     {
       // Async function expression with no await
       code: `const numberOne = async function(): Promise<number> {
-        return 1;
-      }`,
+            return 1;
+          }`,
       errors: [
         {
           messageId: 'missingAwait',
@@ -160,9 +188,85 @@ async function testFunction(): Promise<void> {
         },
       ],
     },
+    {
+      code: 'async function* foo() : void { doSomething() }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: {
+            name: "Async generator function 'foo'",
+          },
+        },
+      ],
+    },
+    {
+      code: 'async function* foo() { yield 1 }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: {
+            name: "Async generator function 'foo'",
+          },
+        },
+      ],
+    },
+    {
+      code: 'async function* run() { console.log("bar") }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: {
+            name: "Async generator function 'run'",
+          },
+        },
+      ],
+    },
+    {
+      code: 'const foo = async function *(){ console.log("bar") }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: {
+            name: 'Async generator function',
+          },
+        },
+      ],
+    },
+    {
+      code: 'async function* syncGenerator() { yield 1 }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: {
+            name: "Async generator function 'syncGenerator'",
+          },
+        },
+      ],
+    },
+    {
+      code: 'async function* test3() { yield asyncGenerator() }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: {
+            name: "Async generator function 'test3'",
+          },
+        },
+      ],
+    },
+    {
+      code: 'async function* test7() { yield syncGenerator() }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: {
+            name: "Async generator function 'test7'",
+          },
+        },
+      ],
+    },
   ],
 });
-
 // base eslint tests
 // https://github.com/eslint/eslint/blob/03a69dbe86d5b5768a310105416ae726822e3c1c/tests/lib/rules/require-await.js#L25-L132
 ruleTester.run('require-await', rule, {
@@ -175,27 +279,23 @@ ruleTester.run('require-await', rule, {
     'class A { async foo() { await doSomething() } }',
     '(class { async foo() { await doSomething() } })',
     'async function foo() { await (async () => { await doSomething() }) }',
-
     // empty functions are ok.
     'async function foo() {}',
     'async () => {}',
-
     // normal functions are ok.
     'function foo() { doSomething() }',
-
     // for-await-of
     'async function foo() { for await (x of xs); }',
-
     // global await
     {
       code: 'await foo()',
     },
     {
       code: `
-        for await (let num of asyncIterable) {
-            console.log(num);
-        }
-      `,
+            for await (let num of asyncIterable) {
+                console.log(num);
+            }
+          `,
     },
   ],
   invalid: [
@@ -289,5 +389,23 @@ ruleTester.run('require-await', rule, {
         },
       ],
     },
+    {
+      code: 'async function* run() { yield * anotherAsyncGenerator() }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: { name: "Async generator function 'run'" },
+        },
+      ],
+    },
+    {
+      code: 'async function* run() { yield* 1 }',
+      errors: [
+        {
+          messageId: 'missingAwait',
+          data: { name: "Async generator function 'run'" },
+        },
+      ],
+    },
   ],
 });

From 188b68979d114ba0957a076fe9c27d154223512c Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Mon, 30 Mar 2020 23:31:50 -0700
Subject: [PATCH 16/36] chore: turn on plugin-test-formatting rule (#1822)

---
 .eslintrc.js                                  |  13 +-
 .../tests/rules/no-typescript-estree.test.ts  |  18 +-
 .../rules/plugin-test-formatting.test.ts      |   1 +
 .../tests/rules/prefer-ast-types-enum.test.ts |  28 +-
 .../adjacent-overload-signatures.test.ts      | 640 ++++++------
 .../tests/rules/array-type.test.ts            | 430 +++++----
 .../tests/rules/await-thenable.test.ts        |  67 +-
 .../tests/rules/ban-ts-comment.test.ts        |  50 +-
 .../tests/rules/ban-ts-ignore.test.ts         |  16 +-
 .../tests/rules/ban-types.test.ts             |  52 +-
 .../tests/rules/brace-style.test.ts           | 352 +++----
 .../tests/rules/camelcase.test.ts             | 200 +++-
 .../class-literal-property-style.test.ts      | 431 ++++++---
 .../tests/rules/class-name-casing.test.ts     |  21 +-
 .../tests/rules/comma-spacing.test.ts         | 347 +++----
 .../rules/consistent-type-definitions.test.ts |  86 +-
 .../tests/rules/default-param-last.test.ts    |  96 +-
 .../explicit-function-return-type.test.ts     | 303 +++---
 .../explicit-member-accessibility.test.ts     | 368 +++----
 .../explicit-module-boundary-types.test.ts    | 306 +++---
 .../tests/rules/func-call-spacing.test.ts     |   9 +-
 .../tests/rules/generic-type-naming.test.ts   |  95 +-
 .../tests/rules/indent/indent-eslint.test.ts  |   5 +
 .../tests/rules/indent/indent.test.ts         | 108 ++-
 .../tests/rules/interface-name-prefix.test.ts |  56 +-
 .../rules/member-delimiter-style.test.ts      | 407 ++++----
 .../tests/rules/member-naming.test.ts         | 186 ++--
 .../tests/rules/member-ordering.test.ts       |   3 +
 .../tests/rules/naming-convention.test.ts     |  23 +-
 .../tests/rules/no-array-constructor.test.ts  |  94 +-
 .../tests/rules/no-base-to-string.test.ts     | 114 ++-
 .../tests/rules/no-dupe-class-members.test.ts | 153 ++-
 .../tests/rules/no-dynamic-delete.test.ts     | 200 ++--
 .../tests/rules/no-empty-function.test.ts     |  65 +-
 .../tests/rules/no-empty-interface.test.ts    |  42 +-
 .../tests/rules/no-explicit-any.test.ts       | 185 ++--
 .../rules/no-extra-non-null-assertion.test.ts |  21 +-
 .../tests/rules/no-extra-parens.test.ts       |   9 +-
 .../tests/rules/no-extra-semi.test.ts         |   5 +
 .../tests/rules/no-extraneous-class.test.ts   |  94 +-
 .../tests/rules/no-floating-promises.test.ts  | 284 ++++--
 .../tests/rules/no-for-in-array.test.ts       |  20 +-
 .../tests/rules/no-implied-eval.test.ts       | 105 +-
 .../tests/rules/no-inferrable-types.test.ts   |  68 +-
 .../tests/rules/no-magic-numbers.test.ts      |  16 +-
 .../tests/rules/no-misused-new.test.ts        | 117 ++-
 .../tests/rules/no-misused-promises.test.ts   | 178 ++--
 .../tests/rules/no-namespace.test.ts          |  22 +-
 ...o-non-null-asserted-optional-chain.test.ts |  62 +-
 .../tests/rules/no-non-null-assertion.test.ts |  68 +-
 .../rules/no-parameter-properties.test.ts     | 264 ++---
 .../tests/rules/no-require-imports.test.ts    |  46 +-
 .../tests/rules/no-this-alias.test.ts         |  42 +-
 .../tests/rules/no-throw-literal.test.ts      |  66 +-
 .../tests/rules/no-type-alias.test.ts         | 384 ++++----
 ...nnecessary-boolean-literal-compare.test.ts |  26 +-
 .../rules/no-unnecessary-condition.test.ts    | 314 +++---
 .../rules/no-unnecessary-qualifier.test.ts    |  86 +-
 .../no-unnecessary-type-arguments.test.ts     | 314 +++---
 .../no-unnecessary-type-assertion.test.ts     | 151 +--
 .../tests/rules/no-unsafe-call.test.ts        |  33 +-
 .../rules/no-unsafe-member-access.test.ts     |  67 +-
 .../tests/rules/no-unsafe-return.test.ts      |  85 +-
 .../rules/no-untyped-public-signature.test.ts | 203 ++--
 .../tests/rules/no-unused-expressions.test.ts |  49 +-
 .../tests/rules/no-unused-vars.test.ts        | 476 ++++-----
 .../tests/rules/no-use-before-define.test.ts  | 324 ++++---
 .../rules/no-useless-constructor.test.ts      | 292 +++++-
 .../tests/rules/no-var-requires.test.ts       |  24 +-
 .../tests/rules/prefer-as-const.test.ts       |  38 +-
 .../tests/rules/prefer-for-of.test.ts         | 156 ++-
 .../tests/rules/prefer-function-type.test.ts  |  61 +-
 .../rules/prefer-namespace-keyword.test.ts    |  28 +-
 .../tests/rules/prefer-optional-chain.test.ts |  74 +-
 .../prefer-readonly-parameter-types.test.ts   | 129 +--
 .../tests/rules/prefer-readonly.test.ts       | 734 ++++++++------
 .../tests/rules/prefer-regexp-exec.test.ts    |  48 +-
 .../rules/promise-function-async.test.ts      | 132 ++-
 .../eslint-plugin/tests/rules/quotes.test.ts  | 123 +--
 .../rules/require-array-sort-compare.test.ts  |  55 +-
 .../tests/rules/require-await.test.ts         | 469 +++++----
 .../rules/restrict-plus-operands.test.ts      | 171 ++--
 .../restrict-template-expressions.test.ts     |  16 +-
 .../tests/rules/return-await.test.ts          | 599 +++++++-----
 .../eslint-plugin/tests/rules/semi.test.ts    | 464 ++++-----
 .../rules/space-before-function-paren.test.ts |   5 +
 .../rules/strict-boolean-expressions.test.ts  | 184 ++--
 .../rules/switch-exhaustiveness-check.test.ts | 314 +++---
 .../rules/triple-slash-reference.test.ts      |  80 +-
 .../rules/type-annotation-spacing.test.ts     | 909 +++++++++---------
 .../eslint-plugin/tests/rules/typedef.test.ts | 412 +++++---
 .../tests/rules/unbound-method.test.ts        |  36 +-
 .../tests/rules/unified-signatures.test.ts    | 307 +++---
 93 files changed, 8819 insertions(+), 6610 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index 39ca61de516..cee2ec901cc 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -174,7 +174,7 @@ module.exports = {
         '@typescript-eslint/internal/no-typescript-estree-import': 'error',
       },
     },
-    // rule source files
+    // plugin rule source files
     {
       files: [
         'packages/eslint-plugin-internal/src/rules/**/*.ts',
@@ -187,6 +187,17 @@ module.exports = {
         'import/no-default-export': 'off',
       },
     },
+    // plugin rule tests
+    {
+      files: [
+        'packages/eslint-plugin-internal/tests/rules/**/*.test.ts',
+        'packages/eslint-plugin-tslint/tests/rules/**/*.test.ts',
+        'packages/eslint-plugin/tests/rules/**/*.test.ts',
+      ],
+      rules: {
+        '@typescript-eslint/internal/plugin-test-formatting': 'error',
+      },
+    },
     // tools and tests
     {
       files: ['**/tools/**/*.ts', '**/tests/**/*.ts'],
diff --git a/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts b/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts
index a76e03b7c1d..74b9478b58a 100644
--- a/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/no-typescript-estree.test.ts
@@ -10,20 +10,20 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-typescript-estree-import', rule, {
   valid: [
-    'import { foo } from "@typescript-eslint/experimental-utils";',
-    'import foo from "@typescript-eslint/experimental-utils";',
-    'import * as foo from "@typescript-eslint/experimental-utils";',
+    "import { foo } from '@typescript-eslint/experimental-utils';",
+    "import foo from '@typescript-eslint/experimental-utils';",
+    "import * as foo from '@typescript-eslint/experimental-utils';",
   ],
   invalid: batchedSingleLineTests({
     code: `
-import { foo } from "@typescript-eslint/typescript-estree";
-import foo from "@typescript-eslint/typescript-estree";
-import * as foo from "@typescript-eslint/typescript-estree";
+import { foo } from '@typescript-eslint/typescript-estree';
+import foo from '@typescript-eslint/typescript-estree';
+import * as foo from '@typescript-eslint/typescript-estree';
     `,
     output: `
-import { foo } from "@typescript-eslint/experimental-utils";
-import foo from "@typescript-eslint/experimental-utils";
-import * as foo from "@typescript-eslint/experimental-utils";
+import { foo } from '@typescript-eslint/experimental-utils';
+import foo from '@typescript-eslint/experimental-utils';
+import * as foo from '@typescript-eslint/experimental-utils';
     `,
     errors: [
       {
diff --git a/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts b/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
index 8d7e0b2c1d8..c2af09bec90 100644
--- a/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/plugin-test-formatting.test.ts
@@ -71,6 +71,7 @@ const a = 1;
 ${PARENT_INDENT}\``,
     wrap`noFormat\`const a = 1;\``,
     // sanity check suggestion validation
+    // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
     `
       ruleTester.run({
         invalid: [
diff --git a/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts b/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts
index 2688e035b59..c2ffd8e489e 100644
--- a/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts
+++ b/packages/eslint-plugin-internal/tests/rules/prefer-ast-types-enum.test.ts
@@ -14,29 +14,29 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('prefer-ast-types-enum', rule, {
   valid: [
-    'node.type === "constructor"',
-    'node.type === AST_NODE_TYPES.Literal',
-    'node.type === AST_TOKEN_TYPES.Keyword',
-    'node.type === 1',
+    "node.type === 'constructor';",
+    'node.type === AST_NODE_TYPES.Literal;',
+    'node.type === AST_TOKEN_TYPES.Keyword;',
+    'node.type === 1;',
     `
-    enum MY_ENUM {
-      Literal = 1
-    }
+      enum MY_ENUM {
+        Literal = 1,
+      }
     `,
     `
-    enum AST_NODE_TYPES {
-      Literal = 'Literal'
-    }
+      enum AST_NODE_TYPES {
+        Literal = 'Literal',
+      }
     `,
   ],
   invalid: batchedSingleLineTests({
     code: `
-node.type === 'Literal'
-node.type === 'Keyword'
+node.type === 'Literal';
+node.type === 'Keyword';
     `,
     output: `
-node.type === AST_NODE_TYPES.Literal
-node.type === AST_TOKEN_TYPES.Keyword
+node.type === AST_NODE_TYPES.Literal;
+node.type === AST_TOKEN_TYPES.Keyword;
     `,
     errors: [
       {
diff --git a/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts b/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
index c040362a128..8e844bb96be 100644
--- a/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/adjacent-overload-signatures.test.ts
@@ -11,217 +11,224 @@ ruleTester.run('adjacent-overload-signatures', rule, {
       code: `
 function error(a: string);
 function error(b: number);
-function error(ab: string|number){ }
+function error(ab: string | number) {}
 export { error };
-            `,
+      `,
       parserOptions: { sourceType: 'module' },
     },
     {
       code: `
 import { connect } from 'react-redux';
-export interface ErrorMessageModel { message: string; }
-function mapStateToProps() { }
-function mapDispatchToProps() { }
+export interface ErrorMessageModel {
+  message: string;
+}
+function mapStateToProps() {}
+function mapDispatchToProps() {}
 export default connect(mapStateToProps, mapDispatchToProps)(ErrorMessage);
-            `,
+      `,
       parserOptions: { sourceType: 'module' },
     },
     `
-export const foo = "a", bar = "b";
+export const foo = 'a',
+  bar = 'b';
 export interface Foo {}
 export class Foo {}
-        `,
+    `,
     `
 export interface Foo {}
-export const foo = "a", bar = "b";
+export const foo = 'a',
+  bar = 'b';
 export class Foo {}
-        `,
+    `,
     `
-const foo = "a", bar = "b";
+const foo = 'a',
+  bar = 'b';
 interface Foo {}
 class Foo {}
-        `,
+    `,
     `
 interface Foo {}
-const foo = "a", bar = "b";
+const foo = 'a',
+  bar = 'b';
 class Foo {}
-        `,
+    `,
     `
 export class Foo {}
 export class Bar {}
 export type FooBar = Foo | Bar;
-        `,
+    `,
     `
 export interface Foo {}
 export class Foo {}
 export class Bar {}
 export type FooBar = Foo | Bar;
-        `,
+    `,
     `
 export function foo(s: string);
 export function foo(n: number);
 export function foo(sn: string | number) {}
 export function bar(): void {}
 export function baz(): void {}
-        `,
+    `,
     `
 function foo(s: string);
 function foo(n: number);
 function foo(sn: string | number) {}
 function bar(): void {}
 function baz(): void {}
-        `,
+    `,
     `
 declare function foo(s: string);
 declare function foo(n: number);
 declare function foo(sn: string | number);
 declare function bar(): void;
 declare function baz(): void;
-        `,
+    `,
     `
-declare module "Foo" {
-    export function foo(s: string): void;
-    export function foo(n: number): void;
-    export function foo(sn: string | number): void;
-    export function bar(): void;
-    export function baz(): void;
-}
-        `,
+declare module 'Foo' {
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function foo(sn: string | number): void;
+  export function bar(): void;
+  export function baz(): void;
+}
+    `,
     `
 declare namespace Foo {
-    export function foo(s: string): void;
-    export function foo(n: number): void;
-    export function foo(sn: string | number): void;
-    export function bar(): void;
-    export function baz(): void;
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function foo(sn: string | number): void;
+  export function bar(): void;
+  export function baz(): void;
 }
-        `,
+    `,
     `
 type Foo = {
-    foo(s: string): void;
-    foo(n: number): void;
-    foo(sn: string | number): void;
-    bar(): void;
-    baz(): void;
-}
-        `,
+  foo(s: string): void;
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
+};
+    `,
     `
 type Foo = {
-    foo(s: string): void;
-    ["foo"](n: number): void;
-    foo(sn: string | number): void;
-    bar(): void;
-    baz(): void;
-}
-        `,
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
+};
+    `,
     `
 interface Foo {
-    (s: string): void;
-    (n: number): void;
-    (sn: string | number): void;
-    foo(n: number): void;
-    bar(): void;
-    baz(): void;
-}
-        `,
+  (s: string): void;
+  (n: number): void;
+  (sn: string | number): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
+}
+    `,
     `
 interface Foo {
-    foo(s: string): void;
-    foo(n: number): void;
-    foo(sn: string | number): void;
-    bar(): void;
-    baz(): void;
+  foo(s: string): void;
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
 }
-        `,
+    `,
     `
 interface Foo {
-    foo(s: string): void;
-    ["foo"](n: number): void;
-    foo(sn: string | number): void;
-    bar(): void;
-    baz(): void;
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
 }
-        `,
+    `,
     `
 interface Foo {
-    foo(): void;
-    bar: {
-        baz(s: string): void;
-        baz(n: number): void;
-        baz(sn: string | number): void;
-    }
-}
-        `,
+  foo(): void;
+  bar: {
+    baz(s: string): void;
+    baz(n: number): void;
+    baz(sn: string | number): void;
+  };
+}
+    `,
     `
 interface Foo {
-    new(s: string);
-    new(n: number);
-    new(sn: string | number);
-    foo(): void;
+  new (s: string);
+  new (n: number);
+  new (sn: string | number);
+  foo(): void;
 }
-        `,
+    `,
     `
 class Foo {
-    constructor(s: string);
-    constructor(n: number);
-    constructor(sn: string | number) {}
-    bar(): void {}
-    baz(): void {}
+  constructor(s: string);
+  constructor(n: number);
+  constructor(sn: string | number) {}
+  bar(): void {}
+  baz(): void {}
 }
-        `,
+    `,
     `
 class Foo {
-    foo(s: string): void;
-    foo(n: number): void;
-    foo(sn: string | number): void {}
-    bar(): void {}
-    baz(): void {}
+  foo(s: string): void;
+  foo(n: number): void;
+  foo(sn: string | number): void {}
+  bar(): void {}
+  baz(): void {}
 }
-        `,
+    `,
     `
 class Foo {
-    foo(s: string): void;
-    ["foo"](n: number): void;
-    foo(sn: string | number): void {}
-    bar(): void {}
-    baz(): void {}
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  foo(sn: string | number): void {}
+  bar(): void {}
+  baz(): void {}
 }
-        `,
+    `,
     `
 class Foo {
-    name: string;
-    foo(s: string): void;
-    foo(n: number): void;
-    foo(sn: string | number): void {}
-    bar(): void {}
-    baz(): void {}
-}
-        `,
+  name: string;
+  foo(s: string): void;
+  foo(n: number): void;
+  foo(sn: string | number): void {}
+  bar(): void {}
+  baz(): void {}
+}
+    `,
     `
 class Foo {
-    name: string;
-    static foo(s: string): void;
-    static foo(n: number): void;
-    static foo(sn: string | number): void {}
-    bar(): void {}
-    baz(): void {}
-}
-        `,
+  name: string;
+  static foo(s: string): void;
+  static foo(n: number): void;
+  static foo(sn: string | number): void {}
+  bar(): void {}
+  baz(): void {}
+}
+    `,
     `
 class Test {
   static test() {}
   untest() {}
   test() {}
 }
-        `,
+    `,
     // examples from https://github.com/nzakas/eslint-plugin-typescript/issues/138
-    'export default function<T>(foo : T) {}',
-    'export default function named<T>(foo : T) {}',
+    'export default function<T>(foo: T) {}',
+    'export default function named<T>(foo: T) {}',
     `
 interface Foo {
   [Symbol.toStringTag](): void;
   [Symbol.iterator](): void;
-}`,
+}
+    `,
   ],
   invalid: [
     {
@@ -231,7 +238,7 @@ export function foo(n: number);
 export function bar(): void {}
 export function baz(): void {}
 export function foo(sn: string | number) {}
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -248,7 +255,7 @@ export function foo(n: number);
 export type bar = number;
 export type baz = number | string;
 export function foo(sn: string | number) {}
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -265,7 +272,7 @@ function foo(n: number);
 function bar(): void {}
 function baz(): void {}
 function foo(sn: string | number) {}
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -282,7 +289,7 @@ function foo(n: number);
 type bar = number;
 type baz = number | string;
 function foo(sn: string | number) {}
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -296,10 +303,10 @@ function foo(sn: string | number) {}
       code: `
 function foo(s: string) {}
 function foo(n: number) {}
-const a = "";
-const b = "";
+const a = '';
+const b = '';
 function foo(sn: string | number) {}
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -315,7 +322,7 @@ function foo(s: string) {}
 function foo(n: number) {}
 class Bar {}
 function foo(sn: string | number) {}
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -331,18 +338,18 @@ function foo(s: string) {}
 function foo(n: number) {}
 function foo(sn: string | number) {}
 class Bar {
-    foo(s: string);
-    foo(n: number);
-    name: string;
-    foo(sn: string | number) { }
+  foo(s: string);
+  foo(n: number);
+  name: string;
+  foo(sn: string | number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 9,
-          column: 5,
+          column: 3,
         },
       ],
     },
@@ -353,7 +360,7 @@ declare function foo(n: number);
 declare function bar(): void;
 declare function baz(): void;
 declare function foo(sn: string | number);
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -367,10 +374,10 @@ declare function foo(sn: string | number);
       code: `
 declare function foo(s: string);
 declare function foo(n: number);
-const a = "";
-const b = "";
+const a = '';
+const b = '';
 declare function foo(sn: string | number);
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
@@ -382,437 +389,438 @@ declare function foo(sn: string | number);
     },
     {
       code: `
-declare module "Foo" {
-    export function foo(s: string): void;
-    export function foo(n: number): void;
-    export function bar(): void;
-    export function baz(): void;
-    export function foo(sn: string | number): void;
+declare module 'Foo' {
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function bar(): void;
+  export function baz(): void;
+  export function foo(sn: string | number): void;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
-declare module "Foo" {
-    export function foo(s: string): void;
-    export function foo(n: number): void;
-    export function foo(sn: string | number): void;
-    function baz(s: string): void;
-    export function bar(): void;
-    function baz(n: number): void;
-    function baz(sn: string | number): void;
+declare module 'Foo' {
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function foo(sn: string | number): void;
+  function baz(s: string): void;
+  export function bar(): void;
+  function baz(n: number): void;
+  function baz(sn: string | number): void;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'baz' },
           line: 8,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 declare namespace Foo {
-    export function foo(s: string): void;
-    export function foo(n: number): void;
-    export function bar(): void;
-    export function baz(): void;
-    export function foo(sn: string | number): void;
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function bar(): void;
+  export function baz(): void;
+  export function foo(sn: string | number): void;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 declare namespace Foo {
-    export function foo(s: string): void;
-    export function foo(n: number): void;
-    export function foo(sn: string | number): void;
-    function baz(s: string): void;
-    export function bar(): void;
-    function baz(n: number): void;
-    function baz(sn: string | number): void;
-}
-            `,
+  export function foo(s: string): void;
+  export function foo(n: number): void;
+  export function foo(sn: string | number): void;
+  function baz(s: string): void;
+  export function bar(): void;
+  function baz(n: number): void;
+  function baz(sn: string | number): void;
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'baz' },
           line: 8,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 type Foo = {
-    foo(s: string): void;
-    foo(n: number): void;
-    bar(): void;
-    baz(): void;
-    foo(sn: string | number): void;
-}
-            `,
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+};
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 type Foo = {
-    foo(s: string): void;
-    ["foo"](n: number): void;
-    bar(): void;
-    baz(): void;
-    foo(sn: string | number): void;
-}
-            `,
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
+};
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 type Foo = {
-    foo(s: string): void;
-    name: string;
-    foo(n: number): void;
-    foo(sn: string | number): void;
-    bar(): void;
-    baz(): void;
-}
-            `,
+  foo(s: string): void;
+  name: string;
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
+};
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 5,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface Foo {
-    (s: string): void;
-    foo(n: number): void;
-    (n: number): void;
-    (sn: string | number): void;
-    bar(): void;
-    baz(): void;
-}
-            `,
+  (s: string): void;
+  foo(n: number): void;
+  (n: number): void;
+  (sn: string | number): void;
+  bar(): void;
+  baz(): void;
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'call' },
           line: 5,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface Foo {
-    foo(s: string): void;
-    foo(n: number): void;
-    bar(): void;
-    baz(): void;
-    foo(sn: string | number): void;
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface Foo {
-    foo(s: string): void;
-    ["foo"](n: number): void;
-    bar(): void;
-    baz(): void;
-    foo(sn: string | number): void;
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface Foo {
-    foo(s: string): void;
-    "foo"(n: number): void;
-    bar(): void;
-    baz(): void;
-    foo(sn: string | number): void;
+  foo(s: string): void;
+  'foo'(n: number): void;
+  bar(): void;
+  baz(): void;
+  foo(sn: string | number): void;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface Foo {
-    foo(s: string): void;
-    name: string;
-    foo(n: number): void;
-    foo(sn: string | number): void;
-    bar(): void;
-    baz(): void;
-}
-            `,
+  foo(s: string): void;
+  name: string;
+  foo(n: number): void;
+  foo(sn: string | number): void;
+  bar(): void;
+  baz(): void;
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 5,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface Foo {
+  foo(): void;
+  bar: {
+    baz(s: string): void;
+    baz(n: number): void;
     foo(): void;
-    bar: {
-        baz(s: string): void;
-        baz(n: number): void;
-        foo(): void;
-        baz(sn: string | number): void;
-    }
-}
-            `,
+    baz(sn: string | number): void;
+  };
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'baz' },
           line: 8,
-          column: 9,
+          column: 5,
         },
       ],
     },
     {
       code: `
 interface Foo {
-    new(s: string);
-    new(n: number);
-    foo(): void;
-    bar(): void;
-    new(sn: string | number);
+  new (s: string);
+  new (n: number);
+  foo(): void;
+  bar(): void;
+  new (sn: string | number);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'new' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface Foo {
-    new(s: string);
-    foo(): void;
-    new(n: number);
-    bar(): void;
-    new(sn: string | number);
+  new (s: string);
+  foo(): void;
+  new (n: number);
+  bar(): void;
+  new (sn: string | number);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'new' },
           line: 5,
-          column: 5,
+          column: 3,
         },
         {
           messageId: 'adjacentSignature',
           data: { name: 'new' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(s: string);
-    constructor(n: number);
-    bar(): void {}
-    baz(): void {}
-    constructor(sn: string | number) {}
+  constructor(s: string);
+  constructor(n: number);
+  bar(): void {}
+  baz(): void {}
+  constructor(sn: string | number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'constructor' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class Foo {
-    foo(s: string): void;
-    foo(n: number): void;
-    bar(): void {}
-    baz(): void {}
-    foo(sn: string | number): void {}
+  foo(s: string): void;
+  foo(n: number): void;
+  bar(): void {}
+  baz(): void {}
+  foo(sn: string | number): void {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class Foo {
-    foo(s: string): void;
-    ["foo"](n: number): void;
-    bar(): void {}
-    baz(): void {}
-    foo(sn: string | number): void {}
+  foo(s: string): void;
+  ['foo'](n: number): void;
+  bar(): void {}
+  baz(): void {}
+  foo(sn: string | number): void {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 7,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class Foo {
-    foo(s: string): void;
-    "foo"(n: number): void;
-    bar(): void {}
-    baz(): void {}
-    foo(sn: string | number): void {}
-}
-            `,
+  // prettier-ignore
+  "foo"(s: string): void;
+  foo(n: number): void;
+  bar(): void {}
+  baz(): void {}
+  foo(sn: string | number): void {}
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
-          line: 7,
-          column: 5,
+          line: 8,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(s: string);
-    name: string;
-    constructor(n: number);
-    constructor(sn: string | number) {}
-    bar(): void {}
-    baz(): void {}
-}
-            `,
+  constructor(s: string);
+  name: string;
+  constructor(n: number);
+  constructor(sn: string | number) {}
+  bar(): void {}
+  baz(): void {}
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'constructor' },
           line: 5,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class Foo {
-    foo(s: string): void;
-    name: string;
-    foo(n: number): void;
-    foo(sn: string | number): void {}
-    bar(): void {}
-    baz(): void {}
-}
-            `,
+  foo(s: string): void;
+  name: string;
+  foo(n: number): void;
+  foo(sn: string | number): void {}
+  bar(): void {}
+  baz(): void {}
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'foo' },
           line: 5,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class Foo {
-    static foo(s: string): void;
-    name: string;
-    static foo(n: number): void;
-    static foo(sn: string | number): void {}
-    bar(): void {}
-    baz(): void {}
-}
-            `,
+  static foo(s: string): void;
+  name: string;
+  static foo(n: number): void;
+  static foo(sn: string | number): void {}
+  bar(): void {}
+  baz(): void {}
+}
+      `,
       errors: [
         {
           messageId: 'adjacentSignature',
           data: { name: 'static foo' },
           line: 5,
-          column: 5,
+          column: 3,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/array-type.test.ts b/packages/eslint-plugin/tests/rules/array-type.test.ts
index b74c06c09fd..5f15ba5e822 100644
--- a/packages/eslint-plugin/tests/rules/array-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/array-type.test.ts
@@ -10,35 +10,35 @@ const ruleTester = new RuleTester({
 ruleTester.run('array-type', rule, {
   valid: [
     {
-      code: 'let a: readonly any[] = []',
+      code: 'let a: readonly any[] = [];',
       options: [{ default: 'array' }],
     },
     {
-      code: 'let a = new Array()',
+      code: 'let a = new Array();',
       options: [{ default: 'array' }],
     },
     {
-      code: 'let a: string[] = []',
+      code: 'let a: string[] = [];',
       options: [{ default: 'array' }],
     },
     {
-      code: 'let a: (string | number)[] = []',
+      code: 'let a: (string | number)[] = [];',
       options: [{ default: 'array' }],
     },
     {
-      code: 'let a: ({ foo: Bar[] })[] = []',
+      code: 'let a: { foo: Bar[] }[] = [];',
       options: [{ default: 'array' }],
     },
     {
-      code: 'let a: Array<string> = []',
+      code: 'let a: Array<string> = [];',
       options: [{ default: 'generic' }],
     },
     {
-      code: 'let a: Array<string | number> = []',
+      code: 'let a: Array<string | number> = [];',
       options: [{ default: 'generic' }],
     },
     {
-      code: 'let a: Array<{ foo: Array<Bar> }> = []',
+      code: 'let a: Array<{ foo: Array<Bar> }> = [];',
       options: [{ default: 'generic' }],
     },
     {
@@ -46,7 +46,7 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'generic' }],
     },
     {
-      code: 'function foo (a: Array<Bar>): Array<Bar> {}',
+      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
       options: [{ default: 'generic' }],
     },
     {
@@ -54,15 +54,19 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'array-simple' }],
     },
     {
-      code: `function fooFunction(foo: Array<ArrayClass<string>>) {
-    return foo.map(e => e.foo);
-}`,
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
+}
+      `,
       options: [{ default: 'array-simple' }],
     },
     {
-      code: `function bazFunction(baz: Arr<ArrayClass<String>>) {
-    return baz.map(e => e.baz);
-}`,
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
+}
+      `,
       options: [{ default: 'array-simple' }],
     },
     {
@@ -78,16 +82,20 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'array-simple' }],
     },
     {
-      code: `namespace fooName {
-    type BarType = { bar: string };
-    type BazType<T> = Arr<T>;
-}`,
+      code: `
+namespace fooName {
+  type BarType = { bar: string };
+  type BazType<T> = Arr<T>;
+}
+      `,
       options: [{ default: 'array-simple' }],
     },
     {
-      code: `interface FooInterface {
-    '.bar': {baz: string[];};
-}`,
+      code: `
+interface FooInterface {
+  '.bar': { baz: string[] };
+}
+      `,
       options: [{ default: 'array-simple' }],
     },
     {
@@ -95,19 +103,23 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'array' }],
     },
     {
-      code: 'let ya = [[1, "2"]] as[number, string][];',
+      code: "let ya = [[1, '2']] as [number, string][];",
       options: [{ default: 'array' }],
     },
     {
-      code: `function barFunction(bar: ArrayClass<String>[]) {
-    return bar.map(e => e.bar);
-}`,
+      code: `
+function barFunction(bar: ArrayClass<String>[]) {
+  return bar.map(e => e.bar);
+}
+      `,
       options: [{ default: 'array' }],
     },
     {
-      code: `function bazFunction(baz: Arr<ArrayClass<String>>) {
-    return baz.map(e => e.baz);
-}`,
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
+}
+      `,
       options: [{ default: 'array' }],
     },
     {
@@ -115,7 +127,7 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'array' }],
     },
     {
-      code: 'type barUnion = (string|number|boolean)[];',
+      code: 'type barUnion = (string | number | boolean)[];',
       options: [{ default: 'array' }],
     },
     {
@@ -123,18 +135,20 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'array' }],
     },
     {
-      code: `interface FooInterface {
-    '.bar': {baz: string[];};
-}`,
+      code: `
+interface FooInterface {
+  '.bar': { baz: string[] };
+}
+      `,
       options: [{ default: 'array' }],
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/172
-      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T',
+      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
       options: [{ default: 'array' }],
     },
     {
-      code: 'let z: Array = [3, "4"];',
+      code: "let z: Array = [3, '4'];",
       options: [{ default: 'generic' }],
     },
     {
@@ -146,15 +160,19 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'generic' }],
     },
     {
-      code: `function fooFunction(foo: Array<ArrayClass<string>>) {
-    return foo.map(e => e.foo);
-}`,
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
+}
+      `,
       options: [{ default: 'generic' }],
     },
     {
-      code: `function bazFunction(baz: Arr<ArrayClass<String>>) {
-    return baz.map(e => e.baz);
-}`,
+      code: `
+function bazFunction(baz: Arr<ArrayClass<String>>) {
+  return baz.map(e => e.baz);
+}
+      `,
       options: [{ default: 'generic' }],
     },
     {
@@ -162,7 +180,7 @@ ruleTester.run('array-type', rule, {
       options: [{ default: 'generic' }],
     },
     {
-      code: 'type fooUnion = Array<string|number|boolean>;',
+      code: 'type fooUnion = Array<string | number | boolean>;',
       options: [{ default: 'generic' }],
     },
     {
@@ -171,40 +189,40 @@ ruleTester.run('array-type', rule, {
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/172
-      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T',
+      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
       options: [{ default: 'generic' }],
     },
 
     // readonly
     {
-      code: 'let a: string[] = []',
+      code: 'let a: string[] = [];',
       options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      code: 'let a: ReadonlyArray<number> = []',
+      code: 'let a: ReadonlyArray<number> = [];',
       options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      code: 'let a: ReadonlyArray<number[]> = [[]]',
+      code: 'let a: ReadonlyArray<number[]> = [[]];',
       options: [{ default: 'array', readonly: 'generic' }],
     },
     {
-      code: 'let a: Array<string> = []',
+      code: 'let a: Array<string> = [];',
       options: [{ default: 'generic', readonly: 'array' }],
     },
     {
-      code: 'let a: readonly number[] = []',
+      code: 'let a: readonly number[] = [];',
       options: [{ default: 'generic', readonly: 'array' }],
     },
     {
-      code: 'let a: readonly Array<number>[] = [[]]',
+      code: 'let a: readonly Array<number>[] = [[]];',
       options: [{ default: 'generic', readonly: 'array' }],
     },
   ],
   invalid: [
     {
-      code: 'let a: Array<string> = []',
-      output: 'let a: string[] = []',
+      code: 'let a: Array<string> = [];',
+      output: 'let a: string[] = [];',
       options: [{ default: 'array' }],
       errors: [
         {
@@ -216,8 +234,8 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let a: Array<string | number> = []',
-      output: 'let a: (string | number)[] = []',
+      code: 'let a: Array<string | number> = [];',
+      output: 'let a: (string | number)[] = [];',
       options: [{ default: 'array' }],
       errors: [
         {
@@ -229,21 +247,21 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let a: ({ foo: Array<Bar> })[] = []',
-      output: 'let a: ({ foo: Bar[] })[] = []',
+      code: 'let a: { foo: Array<Bar> }[] = [];',
+      output: 'let a: { foo: Bar[] }[] = [];',
       options: [{ default: 'array' }],
       errors: [
         {
           messageId: 'errorStringArray',
           data: { type: 'Bar' },
           line: 1,
-          column: 16,
+          column: 15,
         },
       ],
     },
     {
-      code: 'let a: string[] = []',
-      output: 'let a: Array<string> = []',
+      code: 'let a: string[] = [];',
+      output: 'let a: Array<string> = [];',
       options: [{ default: 'generic' }],
       errors: [
         {
@@ -255,8 +273,8 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let a: (string | number)[] = []',
-      output: 'let a: Array<string | number> = []',
+      code: 'let a: (string | number)[] = [];',
+      output: 'let a: Array<string | number> = [];',
       options: [{ default: 'generic' }],
       errors: [
         {
@@ -268,8 +286,8 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let a: Array<{ foo: Bar[] }> = []',
-      output: 'let a: Array<{ foo: Array<Bar> }> = []',
+      code: 'let a: Array<{ foo: Bar[] }> = [];',
+      output: 'let a: Array<{ foo: Array<Bar> }> = [];',
       options: [{ default: 'generic' }],
       errors: [
         {
@@ -281,8 +299,8 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let a: Array<{ foo: Foo | Bar[] }> = []',
-      output: 'let a: Array<{ foo: Foo | Array<Bar> }> = []',
+      code: 'let a: Array<{ foo: Foo | Bar[] }> = [];',
+      output: 'let a: Array<{ foo: Foo | Array<Bar> }> = [];',
       options: [{ default: 'generic' }],
       errors: [
         {
@@ -294,27 +312,27 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'function foo (a: Array<Bar>): Array<Bar> {}',
-      output: 'function foo (a: Bar[]): Bar[] {}',
+      code: 'function foo(a: Array<Bar>): Array<Bar> {}',
+      output: 'function foo(a: Bar[]): Bar[] {}',
       options: [{ default: 'array' }],
       errors: [
         {
           messageId: 'errorStringArray',
           data: { type: 'Bar' },
           line: 1,
-          column: 18,
+          column: 17,
         },
         {
           messageId: 'errorStringArray',
           data: { type: 'Bar' },
           line: 1,
-          column: 31,
+          column: 30,
         },
       ],
     },
     {
-      code: 'let a: Array<>[] = []',
-      output: 'let a: any[][] = []',
+      code: 'let a: Array<>[] = [];',
+      output: 'let a: any[][] = [];',
       options: [{ default: 'array-simple' }],
       errors: [
         {
@@ -358,8 +376,8 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let y: string[] = <Array<string>>["2"];',
-      output: 'let y: string[] = <string[]>["2"];',
+      code: "let y: string[] = <Array<string>>['2'];",
+      output: "let y: string[] = <string[]>['2'];",
       options: [{ default: 'array-simple' }],
       errors: [
         {
@@ -371,8 +389,8 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let z: Array = [3, "4"];',
-      output: 'let z: any[] = [3, "4"];',
+      code: "let z: Array = [3, '4'];",
+      output: "let z: any[] = [3, '4'];",
       options: [{ default: 'array-simple' }],
       errors: [
         {
@@ -384,15 +402,15 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: 'let ya = [[1, "2"]] as[number, string][];',
-      output: 'let ya = [[1, "2"]] as Array<[number, string]>;',
+      code: "let ya = [[1, '2']] as [number, string][];",
+      output: "let ya = [[1, '2']] as Array<[number, string]>;",
       options: [{ default: 'array-simple' }],
       errors: [
         {
           messageId: 'errorStringGenericSimple',
           data: { type: 'T' },
           line: 1,
-          column: 23,
+          column: 24,
         },
       ],
     },
@@ -410,56 +428,68 @@ ruleTester.run('array-type', rule, {
       ],
     },
     {
-      code: `// Ignore user defined aliases
-let yyyy: Arr<Array<Arr<string>>[]> = [[[["2"]]]];`,
-      output: `// Ignore user defined aliases
-let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
+      `,
       options: [{ default: 'array-simple' }],
       errors: [
         {
           messageId: 'errorStringGenericSimple',
           data: { type: 'T' },
-          line: 2,
+          line: 3,
           column: 15,
         },
       ],
     },
     {
-      code: `interface ArrayClass<T> {
-    foo: Array<T>;
-    bar: T[];
-    baz: Arr<T>;
-    xyz: this[];
-}`,
-      output: `interface ArrayClass<T> {
-    foo: T[];
-    bar: T[];
-    baz: Arr<T>;
-    xyz: this[];
-}`,
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+  xyz: this[];
+}
+      `,
+      output: `
+interface ArrayClass<T> {
+  foo: T[];
+  bar: T[];
+  baz: Arr<T>;
+  xyz: this[];
+}
+      `,
       options: [{ default: 'array-simple' }],
       errors: [
         {
           messageId: 'errorStringArraySimple',
           data: { type: 'T' },
-          line: 2,
-          column: 10,
+          line: 3,
+          column: 8,
         },
       ],
     },
     {
-      code: `function barFunction(bar: ArrayClass<String>[]) {
-    return bar.map(e => e.bar);
-}`,
-      output: `function barFunction(bar: Array<ArrayClass<String>>) {
-    return bar.map(e => e.bar);
-}`,
+      code: `
+function barFunction(bar: ArrayClass<String>[]) {
+  return bar.map(e => e.bar);
+}
+      `,
+      output: `
+function barFunction(bar: Array<ArrayClass<String>>) {
+  return bar.map(e => e.bar);
+}
+      `,
       options: [{ default: 'array-simple' }],
       errors: [
         {
           messageId: 'errorStringGenericSimple',
           data: { type: 'T' },
-          line: 1,
+          line: 2,
           column: 27,
         },
       ],
@@ -478,8 +508,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'type barUnion = (string|number|boolean)[];',
-      output: 'type barUnion = Array<string|number|boolean>;',
+      code: 'type barUnion = (string | number | boolean)[];',
+      output: 'type barUnion = Array<string | number | boolean>;',
       options: [{ default: 'array-simple' }],
       errors: [
         {
@@ -504,8 +534,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'let v: Array<fooName.BarType> = [{ bar: "bar" }];',
-      output: 'let v: fooName.BarType[] = [{ bar: "bar" }];',
+      code: "let v: Array<fooName.BarType> = [{ bar: 'bar' }];",
+      output: "let v: fooName.BarType[] = [{ bar: 'bar' }];",
       options: [{ default: 'array-simple' }],
       errors: [
         {
@@ -517,8 +547,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'let w: fooName.BazType<string>[] = [["baz"]];',
-      output: 'let w: Array<fooName.BazType<string>> = [["baz"]];',
+      code: "let w: fooName.BazType<string>[] = [['baz']];",
+      output: "let w: Array<fooName.BazType<string>> = [['baz']];",
       options: [{ default: 'array-simple' }],
       errors: [
         {
@@ -543,8 +573,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'let y: string[] = <Array<string>>["2"];',
-      output: 'let y: string[] = <string[]>["2"];',
+      code: "let y: string[] = <Array<string>>['2'];",
+      output: "let y: string[] = <string[]>['2'];",
       options: [{ default: 'array' }],
       errors: [
         {
@@ -556,8 +586,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'let z: Array = [3, "4"];',
-      output: 'let z: any[] = [3, "4"];',
+      code: "let z: Array = [3, '4'];",
+      output: "let z: any[] = [3, '4'];",
       options: [{ default: 'array' }],
       errors: [
         {
@@ -582,54 +612,66 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: `// Ignore user defined aliases
-let yyyy: Arr<Array<Arr<string>>[]> = [[[["2"]]]];`,
-      output: `// Ignore user defined aliases
-let yyyy: Arr<Arr<string>[][]> = [[[["2"]]]];`,
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Arr<string>[][]> = [[[['2']]]];
+      `,
       options: [{ default: 'array' }],
       errors: [
         {
           messageId: 'errorStringArray',
           data: { type: 'T' },
-          line: 2,
+          line: 3,
           column: 15,
         },
       ],
     },
     {
-      code: `interface ArrayClass<T> {
-    foo: Array<T>;
-    bar: T[];
-    baz: Arr<T>;
-}`,
-      output: `interface ArrayClass<T> {
-    foo: T[];
-    bar: T[];
-    baz: Arr<T>;
-}`,
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
+      output: `
+interface ArrayClass<T> {
+  foo: T[];
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
       options: [{ default: 'array' }],
       errors: [
         {
           messageId: 'errorStringArray',
           data: { type: 'T' },
-          line: 2,
-          column: 10,
+          line: 3,
+          column: 8,
         },
       ],
     },
     {
-      code: `function fooFunction(foo: Array<ArrayClass<string>>) {
-    return foo.map(e => e.foo);
-}`,
-      output: `function fooFunction(foo: ArrayClass<string>[]) {
-    return foo.map(e => e.foo);
-}`,
+      code: `
+function fooFunction(foo: Array<ArrayClass<string>>) {
+  return foo.map(e => e.foo);
+}
+      `,
+      output: `
+function fooFunction(foo: ArrayClass<string>[]) {
+  return foo.map(e => e.foo);
+}
+      `,
       options: [{ default: 'array' }],
       errors: [
         {
           messageId: 'errorStringArray',
           data: { type: 'T' },
-          line: 1,
+          line: 2,
           column: 27,
         },
       ],
@@ -648,8 +690,8 @@ let yyyy: Arr<Arr<string>[][]> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'type fooUnion = Array<string|number|boolean>;',
-      output: 'type fooUnion = (string|number|boolean)[];',
+      code: 'type fooUnion = Array<string | number | boolean>;',
+      output: 'type fooUnion = (string | number | boolean)[];',
       options: [{ default: 'array' }],
       errors: [
         {
@@ -711,8 +753,8 @@ let yyyy: Arr<Arr<string>[][]> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'let y: string[] = <Array<string>>["2"];',
-      output: 'let y: Array<string> = <Array<string>>["2"];',
+      code: "let y: string[] = <Array<string>>['2'];",
+      output: "let y: Array<string> = <Array<string>>['2'];",
       options: [{ default: 'generic' }],
       errors: [
         {
@@ -724,67 +766,79 @@ let yyyy: Arr<Arr<string>[][]> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'let ya = [[1, "2"]] as[number, string][];',
-      output: 'let ya = [[1, "2"]] as Array<[number, string]>;',
+      code: "let ya = [[1, '2']] as [number, string][];",
+      output: "let ya = [[1, '2']] as Array<[number, string]>;",
       options: [{ default: 'generic' }],
       errors: [
         {
           messageId: 'errorStringGeneric',
           data: { type: 'T' },
           line: 1,
-          column: 23,
+          column: 24,
         },
       ],
     },
     {
-      code: `// Ignore user defined aliases
-let yyyy: Arr<Array<Arr<string>>[]> = [[[["2"]]]];`,
-      output: `// Ignore user defined aliases
-let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
+      code: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Arr<string>>[]> = [[[['2']]]];
+      `,
+      output: `
+// Ignore user defined aliases
+let yyyy: Arr<Array<Array<Arr<string>>>> = [[[['2']]]];
+      `,
       options: [{ default: 'generic' }],
       errors: [
         {
           messageId: 'errorStringGeneric',
           data: { type: 'T' },
-          line: 2,
+          line: 3,
           column: 15,
         },
       ],
     },
     {
-      code: `interface ArrayClass<T> {
-    foo: Array<T>;
-    bar: T[];
-    baz: Arr<T>;
-}`,
-      output: `interface ArrayClass<T> {
-    foo: Array<T>;
-    bar: Array<T>;
-    baz: Arr<T>;
-}`,
+      code: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: T[];
+  baz: Arr<T>;
+}
+      `,
+      output: `
+interface ArrayClass<T> {
+  foo: Array<T>;
+  bar: Array<T>;
+  baz: Arr<T>;
+}
+      `,
       options: [{ default: 'generic' }],
       errors: [
         {
           messageId: 'errorStringGeneric',
           data: { type: 'T' },
-          line: 3,
-          column: 10,
+          line: 4,
+          column: 8,
         },
       ],
     },
     {
-      code: `function barFunction(bar: ArrayClass<String>[]) {
-    return bar.map(e => e.bar);
-}`,
-      output: `function barFunction(bar: Array<ArrayClass<String>>) {
-    return bar.map(e => e.bar);
-}`,
+      code: `
+function barFunction(bar: ArrayClass<String>[]) {
+  return bar.map(e => e.bar);
+}
+      `,
+      output: `
+function barFunction(bar: Array<ArrayClass<String>>) {
+  return bar.map(e => e.bar);
+}
+      `,
       options: [{ default: 'generic' }],
       errors: [
         {
           messageId: 'errorStringGeneric',
           data: { type: 'T' },
-          line: 1,
+          line: 2,
           column: 27,
         },
       ],
@@ -803,8 +857,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'type barUnion = (string|number|boolean)[];',
-      output: 'type barUnion = Array<string|number|boolean>;',
+      code: 'type barUnion = (string | number | boolean)[];',
+      output: 'type barUnion = Array<string | number | boolean>;',
       options: [{ default: 'generic' }],
       errors: [
         {
@@ -829,26 +883,30 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: `interface FooInterface {
-    '.bar': {baz: string[];};
-}`,
-      output: `interface FooInterface {
-    '.bar': {baz: Array<string>;};
-}`,
+      code: `
+interface FooInterface {
+  '.bar': { baz: string[] };
+}
+      `,
+      output: `
+interface FooInterface {
+  '.bar': { baz: Array<string> };
+}
+      `,
       options: [{ default: 'generic' }],
       errors: [
         {
           messageId: 'errorStringGeneric',
           data: { type: 'string' },
-          line: 2,
-          column: 19,
+          line: 3,
+          column: 18,
         },
       ],
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/172
-      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T',
-      output: 'type Unwrap<T> = T extends (infer E)[] ? E : T',
+      code: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
+      output: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
       options: [{ default: 'array' }],
       errors: [
         {
@@ -861,8 +919,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/172
-      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T',
-      output: 'type Unwrap<T> = T extends Array<infer E> ? E : T',
+      code: 'type Unwrap<T> = T extends (infer E)[] ? E : T;',
+      output: 'type Unwrap<T> = T extends Array<infer E> ? E : T;',
       options: [{ default: 'generic' }],
       errors: [
         {
@@ -928,8 +986,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'const x: readonly number[] = []',
-      output: 'const x: ReadonlyArray<number> = []',
+      code: 'const x: readonly number[] = [];',
+      output: 'const x: ReadonlyArray<number> = [];',
       options: [{ default: 'array', readonly: 'generic' }],
       errors: [
         {
@@ -941,8 +999,8 @@ let yyyy: Arr<Array<Array<Arr<string>>>> = [[[["2"]]]];`,
       ],
     },
     {
-      code: 'const x: readonly number[][] = []',
-      output: 'const x: readonly Array<number>[] = []',
+      code: 'const x: readonly number[][] = [];',
+      output: 'const x: readonly Array<number>[] = [];',
       options: [{ default: 'generic', readonly: 'array' }],
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/await-thenable.test.ts b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
index 5ee0f7d0341..52fc1ca2306 100644
--- a/packages/eslint-plugin/tests/rules/await-thenable.test.ts
+++ b/packages/eslint-plugin/tests/rules/await-thenable.test.ts
@@ -13,51 +13,51 @@ const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
 });
 
-ruleTester.run('await-promise', rule, {
+ruleTester.run('await-thenable', rule, {
   valid: [
     `
 async function test() {
-  await Promise.resolve("value");
-  await Promise.reject(new Error("message"));
+  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");
+    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> {}
@@ -68,7 +68,7 @@ async function test() {
   const bar: Bar = Bar.resolve(2);
   await bar;
 }
-`,
+    `,
     `
 async function test() {
   await (Math.random() > 0.5 ? numberPromise : 0);
@@ -78,15 +78,17 @@ async function test() {
   const intersectionPromise: Promise<number> & number;
   await intersectionPromise;
 }
-`,
+    `,
     `
 async function test() {
-  class Thenable { then(callback: () => {}) { } };
+  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
@@ -96,7 +98,7 @@ async function test() {
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 interface PromisePolyfillConstructor extends PromiseConstructor {
-    _immediateFn?: (handler: (() => void) | string) => void;
+  _immediateFn?: (handler: (() => void) | string) => void;
 }
 
 declare const PromisePolyfill: PromisePolyfillConstructor;
@@ -106,7 +108,7 @@ async function test() {
 
   await promise;
 }
-`,
+    `,
     `
 // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/bluebird/index.d.ts
 // Type definitions for bluebird 3.5
@@ -151,14 +153,21 @@ 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>;
+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<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>;
+    onfulfilled?: ((value: R) => Resolvable<TResult1>) | null,
+    onrejected?: ((reason: any) => Resolvable<TResult2>) | null,
+  ): Bluebird<TResult1 | TResult2>;
 }
 
 declare const bluebird: Bluebird;
@@ -166,7 +175,7 @@ declare const bluebird: Bluebird;
 async function test() {
   await bluebird;
 }
-`,
+    `,
   ],
 
   invalid: [
@@ -174,14 +183,14 @@ async function test() {
       code: `
 async function test() {
   await 0;
-  await "value";
+  await 'value';
 
-  await (Math.random() > 0.5 ? "" : 0);
+  await (Math.random() > 0.5 ? '' : 0);
 
   class NonPromise extends Array {}
   await new NonPromise();
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -204,7 +213,9 @@ async function test() {
     {
       code: `
 async function test() {
-  class IncorrectThenable { then() { } };
+  class IncorrectThenable {
+    then() {}
+  }
   const thenable = new IncorrectThenable();
 
   await thenable;
@@ -212,7 +223,7 @@ async function test() {
       `,
       errors: [
         {
-          line: 6,
+          line: 8,
           messageId,
         },
       ],
diff --git a/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts b/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
index c2226f7041a..fcbb788a308 100644
--- a/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-ts-comment.test.ts
@@ -5,14 +5,16 @@ const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
 });
 
-ruleTester.run('ts-ignore', rule, {
+ruleTester.run('ban-ts-comment', rule, {
   valid: [
-    `// just a comment containing @ts-ignore somewhere`,
-    `/* @ts-ignore */`,
-    `/** @ts-ignore */`,
-    `/*
+    '// just a comment containing @ts-ignore somewhere',
+    '/* @ts-ignore */',
+    '/** @ts-ignore */',
+    `
+/*
 // @ts-ignore in a block
-*/`,
+*/
+    `,
     {
       code: '// @ts-ignore',
       options: [{ 'ts-ignore': false }],
@@ -68,9 +70,9 @@ ruleTester.run('ts-ignore', rule, {
       code: `
 if (false) {
   // @ts-ignore: Unreachable code error
-  console.log("hello");
+  console.log('hello');
 }
-            `,
+      `,
       errors: [
         {
           data: { directive: 'ignore' },
@@ -85,12 +87,14 @@ if (false) {
 
 ruleTester.run('ts-nocheck', rule, {
   valid: [
-    `// just a comment containing @ts-nocheck somewhere`,
-    `/* @ts-nocheck */`,
-    `/** @ts-nocheck */`,
-    `/*
+    '// just a comment containing @ts-nocheck somewhere',
+    '/* @ts-nocheck */',
+    '/** @ts-nocheck */',
+    `
+/*
 // @ts-nocheck in a block
-*/`,
+*/
+    `,
     {
       code: '// @ts-nocheck',
       options: [{ 'ts-nocheck': false }],
@@ -146,9 +150,9 @@ ruleTester.run('ts-nocheck', rule, {
       code: `
 if (false) {
   // @ts-nocheck: Unreachable code error
-  console.log("hello");
+  console.log('hello');
 }
-            `,
+      `,
       errors: [
         {
           data: { directive: 'nocheck' },
@@ -163,12 +167,14 @@ if (false) {
 
 ruleTester.run('ts-check', rule, {
   valid: [
-    `// just a comment containing @ts-check somewhere`,
-    `/* @ts-check */`,
-    `/** @ts-check */`,
-    `/*
+    '// just a comment containing @ts-check somewhere',
+    '/* @ts-check */',
+    '/** @ts-check */',
+    `
+/*
 // @ts-check in a block
-*/`,
+*/
+    `,
     {
       code: '// @ts-check',
       options: [{ 'ts-check': false }],
@@ -216,9 +222,9 @@ ruleTester.run('ts-check', rule, {
       code: `
 if (false) {
   // @ts-check: Unreachable code error
-  console.log("hello");
+  console.log('hello');
 }
-            `,
+      `,
       options: [{ 'ts-check': true }],
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/ban-ts-ignore.test.ts b/packages/eslint-plugin/tests/rules/ban-ts-ignore.test.ts
index d9132df2b0d..e1471950f46 100644
--- a/packages/eslint-plugin/tests/rules/ban-ts-ignore.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-ts-ignore.test.ts
@@ -7,12 +7,14 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('ban-ts-ignore', rule, {
   valid: [
-    `// just a comment containing @ts-ignore somewhere`,
-    `/* @ts-ignore */`,
-    `/** @ts-ignore */`,
-    `/*
+    '// just a comment containing @ts-ignore somewhere',
+    '/* @ts-ignore */',
+    '/** @ts-ignore */',
+    `
+/*
 // @ts-ignore in a block
-*/`,
+*/
+    `,
   ],
   invalid: [
     {
@@ -49,9 +51,9 @@ ruleTester.run('ban-ts-ignore', rule, {
       code: `
 if (false) {
   // @ts-ignore: Unreachable code error
-  console.log("hello");
+  console.log('hello');
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'tsIgnoreComment',
diff --git a/packages/eslint-plugin/tests/rules/ban-types.test.ts b/packages/eslint-plugin/tests/rules/ban-types.test.ts
index 0edeb74f8d1..772fa7716f8 100644
--- a/packages/eslint-plugin/tests/rules/ban-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/ban-types.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/ban-types';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 import { InferOptionsTypeFromRule } from '../../src/util';
 
 const ruleTester = new RuleTester({
@@ -47,7 +47,7 @@ ruleTester.run('ban-types', rule, {
   valid: [
     'let f = Object();', // Should not fail if there is no options set
     'let f: {} = {};',
-    'let f: { x: number, y: number } = { x: 1, y: 1 };',
+    'let f: { x: number; y: number } = { x: 1, y: 1 };',
     {
       code: 'let f = Object();',
       options,
@@ -65,11 +65,11 @@ ruleTester.run('ban-types', rule, {
       options,
     },
     {
-      code: 'let a: _.NS.Bad',
+      code: 'let a: _.NS.Bad;',
       options,
     },
     {
-      code: 'let a: NS.Bad._',
+      code: 'let a: NS.Bad._;',
       options,
     },
     // Replace default options instead of merging with extendDefaults: false
@@ -88,11 +88,11 @@ ruleTester.run('ban-types', rule, {
       ],
     },
     {
-      code: 'let a: undefined',
+      code: 'let a: undefined;',
       options: options2,
     },
     {
-      code: 'let a: null',
+      code: 'let a: null;',
       options: options3,
     },
   ],
@@ -166,8 +166,8 @@ ruleTester.run('ban-types', rule, {
       ],
     },
     {
-      code: 'let b: {c: String};',
-      output: 'let b: {c: string};',
+      code: 'let b: { c: String };',
+      output: 'let b: { c: string };',
       errors: [
         {
           messageId: 'bannedTypeMessage',
@@ -177,7 +177,7 @@ ruleTester.run('ban-types', rule, {
             customMessage: ' Use string instead.',
           },
           line: 1,
-          column: 12,
+          column: 13,
         },
       ],
       options,
@@ -231,22 +231,22 @@ ruleTester.run('ban-types', rule, {
     {
       code: `
 class Foo<F = String> extends Bar<String> implements Baz<Object> {
-  constructor (foo: String | Object) {}
+  constructor(foo: String | Object) {}
 
-  exit() : Array<String> {
-    const foo: String = 1 as String
+  exit(): Array<String> {
+    const foo: String = 1 as String;
   }
 }
-            `,
+      `,
       output: `
 class Foo<F = string> extends Bar<string> implements Baz<Object> {
-  constructor (foo: string | Object) {}
+  constructor(foo: string | Object) {}
 
-  exit() : Array<string> {
-    const foo: string = 1 as string
+  exit(): Array<string> {
+    const foo: string = 1 as string;
   }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'bannedTypeMessage',
@@ -285,7 +285,7 @@ class Foo<F = string> extends Bar<string> implements Baz<Object> {
             customMessage: ' Use string instead.',
           },
           line: 3,
-          column: 21,
+          column: 20,
         },
         {
           messageId: 'bannedTypeMessage',
@@ -294,13 +294,13 @@ class Foo<F = string> extends Bar<string> implements Baz<Object> {
             customMessage: " Use '{}' instead.",
           },
           line: 3,
-          column: 30,
+          column: 29,
         },
         {
           messageId: 'bannedTypeMessage',
           data: { name: 'Array', customMessage: '' },
           line: 5,
-          column: 12,
+          column: 11,
         },
         {
           messageId: 'bannedTypeMessage',
@@ -310,7 +310,7 @@ class Foo<F = string> extends Bar<string> implements Baz<Object> {
             customMessage: ' Use string instead.',
           },
           line: 5,
-          column: 18,
+          column: 17,
         },
         {
           messageId: 'bannedTypeMessage',
@@ -383,8 +383,8 @@ let b: Foo<NS.Good>;
       options,
     },
     {
-      code: `let foo: {} = {};`,
-      output: `let foo: object = {};`,
+      code: 'let foo: {} = {};',
+      output: 'let foo: object = {};',
       options: [
         {
           types: {
@@ -408,7 +408,7 @@ let b: Foo<NS.Good>;
       ],
     },
     {
-      code: `
+      code: noFormat`
 let foo: {} = {};
 let bar: {     } = {};
       `,
@@ -473,8 +473,8 @@ let bar: object = {};
       ],
     },
     {
-      code: 'let a: Foo<   F   >;',
-      output: 'let a: Foo<   T   >;',
+      code: noFormat`let a: Foo<   F   >;`,
+      output: noFormat`let a: Foo<   T   >;`,
       errors: [
         {
           messageId: 'bannedTypeMessage',
diff --git a/packages/eslint-plugin/tests/rules/brace-style.test.ts b/packages/eslint-plugin/tests/rules/brace-style.test.ts
index 21d10998eac..28b9413795d 100644
--- a/packages/eslint-plugin/tests/rules/brace-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/brace-style.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the position of braces, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import rule from '../../src/rules/brace-style';
 import { RuleTester } from '../RuleTester';
 
@@ -211,67 +216,67 @@ catch (e)
       options: ['allman'],
     },
     {
-      code: `function foo () { return; }`,
+      code: 'function foo () { return; }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `function foo () { a(); b(); return; }`,
+      code: 'function foo () { a(); b(); return; }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `function a(b,c,d) { }`,
+      code: 'function a(b,c,d) { }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `!function foo () { return; }`,
+      code: '!function foo () { return; }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `!function a(b,c,d) { }`,
+      code: '!function a(b,c,d) { }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `if (foo) {  bar(); }`,
+      code: 'if (foo) {  bar(); }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `if (a) { b(); } else { c(); }`,
+      code: 'if (a) { b(); } else { c(); }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `while (foo) {  bar(); }`,
+      code: 'while (foo) {  bar(); }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `for (;;) {  bar(); }`,
+      code: 'for (;;) {  bar(); }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `with (foo) {  bar(); }`,
+      code: 'with (foo) {  bar(); }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `switch (foo) {  case 'bar': break; }`,
+      code: "switch (foo) {  case 'bar': break; }",
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `try {  bar(); } catch (e) { baz();  }`,
+      code: 'try {  bar(); } catch (e) { baz();  }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `do {  bar(); } while (true)`,
+      code: 'do {  bar(); } while (true)',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `for (foo in bar) {  baz();  }`,
+      code: 'for (foo in bar) {  baz();  }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `if (a && b && c) {  }`,
+      code: 'if (a && b && c) {  }',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `switch(0) {}`,
+      code: 'switch(0) {}',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
@@ -289,7 +294,7 @@ catch (e) { baz(); }
       options: ['stroustrup', { allowSingleLine: true }],
     },
     {
-      code: `var foo = () => { return; }`,
+      code: 'var foo = () => { return; }',
       options: ['stroustrup', { allowSingleLine: true }],
       parserOptions: { ecmaVersion: 6 },
     },
@@ -308,7 +313,7 @@ catch (e) { baz();  }
       options: ['allman', { allowSingleLine: true }],
     },
     {
-      code: `var foo = () => { return; }`,
+      code: 'var foo = () => { return; }',
       options: ['allman', { allowSingleLine: true }],
       parserOptions: { ecmaVersion: 6 },
     },
@@ -345,7 +350,7 @@ switch(x)
       options: ['allman'],
     },
     {
-      code: `switch(x) {}`,
+      code: 'switch(x) {}',
       options: ['allman', { allowSingleLine: true }],
     },
     {
@@ -388,25 +393,25 @@ Foo
       options: ['allman'],
     },
     {
-      code: `class Foo {}`,
+      code: 'class Foo {}',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `class Foo {}`,
+      code: 'class Foo {}',
       options: ['allman', { allowSingleLine: true }],
     },
     {
-      code: `(class {})`,
+      code: '(class {})',
       options: ['1tbs', { allowSingleLine: true }],
     },
     {
-      code: `(class {})`,
+      code: '(class {})',
       options: ['allman', { allowSingleLine: true }],
     },
 
     // https://github.com/eslint/eslint/issues/7908
     {
-      code: `{}`,
+      code: '{}',
     },
     {
       code: `
@@ -568,7 +573,7 @@ enum Foo {
       options: ['stroustrup'],
     },
     {
-      code: `enum Foo { A, B }`,
+      code: 'enum Foo { A, B }',
       options: ['1tbs', { allowSingleLine: true }],
     },
   ],
@@ -591,8 +596,8 @@ if (f) {
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `var foo = () => { return; }`,
-      output: `var foo = () => {\n return; \n}`,
+      code: 'var foo = () => { return; }',
+      output: 'var foo = () => {\n return; \n}',
       parserOptions: { ecmaVersion: 6 },
       errors: [
         { messageId: 'blockSameLine' },
@@ -600,31 +605,31 @@ if (f) {
       ],
     },
     {
-      code: `function foo() { return; }`,
-      output: `function foo() {\n return; \n}`,
+      code: 'function foo() { return; }',
+      output: 'function foo() {\n return; \n}',
       errors: [
         { messageId: 'blockSameLine' },
         { messageId: 'singleLineClose' },
       ],
     },
     {
-      code: `function foo() \n { \n return; }`,
-      output: `function foo() { \n return; \n}`,
+      code: 'function foo() \n { \n return; }',
+      output: 'function foo() { \n return; \n}',
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `!function foo() \n { \n return; }`,
-      output: `!function foo() { \n return; \n}`,
+      code: '!function foo() \n { \n return; }',
+      output: '!function foo() { \n return; \n}',
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `if (foo) \n { \n bar(); }`,
-      output: `if (foo) { \n bar(); \n}`,
+      code: 'if (foo) \n { \n bar(); }',
+      output: 'if (foo) { \n bar(); \n}',
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `if (a) { \nb();\n } else \n { c(); }`,
-      output: `if (a) { \nb();\n } else {\n c(); \n}`,
+      code: 'if (a) { \nb();\n } else \n { c(); }',
+      output: 'if (a) { \nb();\n } else {\n c(); \n}',
       errors: [
         { messageId: 'nextLineOpen' },
         { messageId: 'blockSameLine' },
@@ -632,104 +637,108 @@ if (f) {
       ],
     },
     {
-      code: `while (foo) \n { \n bar(); }`,
-      output: `while (foo) { \n bar(); \n}`,
+      code: 'while (foo) \n { \n bar(); }',
+      output: 'while (foo) { \n bar(); \n}',
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `for (;;) \n { \n bar(); }`,
-      output: `for (;;) { \n bar(); \n}`,
+      code: 'for (;;) \n { \n bar(); }',
+      output: 'for (;;) { \n bar(); \n}',
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `with (foo) \n { \n bar(); }`,
-      output: `with (foo) { \n bar(); \n}`,
+      code: 'with (foo) \n { \n bar(); }',
+      output: 'with (foo) { \n bar(); \n}',
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `switch (foo) \n { \n case 'bar': break; }`,
-      output: `switch (foo) { \n case 'bar': break; \n}`,
+      code: "switch (foo) \n { \n case 'bar': break; }",
+      output: "switch (foo) { \n case 'bar': break; \n}",
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `switch (foo) \n { }`,
-      output: `switch (foo) { }`,
+      code: 'switch (foo) \n { }',
+      output: 'switch (foo) { }',
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `try \n { \n bar(); \n } catch (e) {}`,
-      output: `try { \n bar(); \n } catch (e) {}`,
+      code: 'try \n { \n bar(); \n } catch (e) {}',
+      output: 'try { \n bar(); \n } catch (e) {}',
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `try { \n bar(); \n } catch (e) \n {}`,
-      output: `try { \n bar(); \n } catch (e) {}`,
+      code: 'try { \n bar(); \n } catch (e) \n {}',
+      output: 'try { \n bar(); \n } catch (e) {}',
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `do \n { \n bar(); \n} while (true)`,
-      output: `do { \n bar(); \n} while (true)`,
+      code: 'do \n { \n bar(); \n} while (true)',
+      output: 'do { \n bar(); \n} while (true)',
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `for (foo in bar) \n { \n baz(); \n }`,
-      output: `for (foo in bar) { \n baz(); \n }`,
+      code: 'for (foo in bar) \n { \n baz(); \n }',
+      output: 'for (foo in bar) { \n baz(); \n }',
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `for (foo of bar) \n { \n baz(); \n }`,
-      output: `for (foo of bar) { \n baz(); \n }`,
+      code: 'for (foo of bar) \n { \n baz(); \n }',
+      output: 'for (foo of bar) { \n baz(); \n }',
       parserOptions: { ecmaVersion: 6 },
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `try { \n bar(); \n }\ncatch (e) {\n}`,
-      output: `try { \n bar(); \n } catch (e) {\n}`,
+      code: 'try { \n bar(); \n }\ncatch (e) {\n}',
+      output: 'try { \n bar(); \n } catch (e) {\n}',
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `try { \n bar(); \n } catch (e) {\n}\n finally {\n}`,
-      output: `try { \n bar(); \n } catch (e) {\n} finally {\n}`,
+      code: 'try { \n bar(); \n } catch (e) {\n}\n finally {\n}',
+      output: 'try { \n bar(); \n } catch (e) {\n} finally {\n}',
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `if (a) { \nb();\n } \n else { \nc();\n }`,
-      output: `if (a) { \nb();\n } else { \nc();\n }`,
+      code: 'if (a) { \nb();\n } \n else { \nc();\n }',
+      output: 'if (a) { \nb();\n } else { \nc();\n }',
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `try { \n bar(); \n }\ncatch (e) {\n} finally {\n}`,
-      output: `try { \n bar(); \n }\ncatch (e) {\n}\n finally {\n}`,
+      code: 'try { \n bar(); \n }\ncatch (e) {\n} finally {\n}',
+      output: 'try { \n bar(); \n }\ncatch (e) {\n}\n finally {\n}',
       options: ['stroustrup'],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `try { \n bar(); \n } catch (e) {\n}\n finally {\n}`,
-      output: `try { \n bar(); \n }\n catch (e) {\n}\n finally {\n}`,
+      code: 'try { \n bar(); \n } catch (e) {\n}\n finally {\n}',
+      output: 'try { \n bar(); \n }\n catch (e) {\n}\n finally {\n}',
       options: ['stroustrup'],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `if (a) { \nb();\n } else { \nc();\n }`,
-      output: `if (a) { \nb();\n }\n else { \nc();\n }`,
+      code: 'if (a) { \nb();\n } else { \nc();\n }',
+      output: 'if (a) { \nb();\n }\n else { \nc();\n }',
       options: ['stroustrup'],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `if (foo) {\nbaz();\n} else if (bar) {\nbaz();\n}\nelse {\nqux();\n}`,
-      output: `if (foo) {\nbaz();\n}\n else if (bar) {\nbaz();\n}\nelse {\nqux();\n}`,
+      code:
+        'if (foo) {\nbaz();\n} else if (bar) {\nbaz();\n}\nelse {\nqux();\n}',
+      output:
+        'if (foo) {\nbaz();\n}\n else if (bar) {\nbaz();\n}\nelse {\nqux();\n}',
       options: ['stroustrup'],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `if (foo) {\npoop();\n} \nelse if (bar) {\nbaz();\n} else if (thing) {\nboom();\n}\nelse {\nqux();\n}`,
-      output: `if (foo) {\npoop();\n} \nelse if (bar) {\nbaz();\n}\n else if (thing) {\nboom();\n}\nelse {\nqux();\n}`,
+      code:
+        'if (foo) {\npoop();\n} \nelse if (bar) {\nbaz();\n} else if (thing) {\nboom();\n}\nelse {\nqux();\n}',
+      output:
+        'if (foo) {\npoop();\n} \nelse if (bar) {\nbaz();\n}\n else if (thing) {\nboom();\n}\nelse {\nqux();\n}',
       options: ['stroustrup'],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `try { \n bar(); \n }\n catch (e) {\n}\n finally {\n}`,
-      output: `try \n{ \n bar(); \n }\n catch (e) \n{\n}\n finally \n{\n}`,
+      code: 'try { \n bar(); \n }\n catch (e) {\n}\n finally {\n}',
+      output: 'try \n{ \n bar(); \n }\n catch (e) \n{\n}\n finally \n{\n}',
       options: ['allman'],
       errors: [
         { messageId: 'sameLineOpen', line: 1 },
@@ -738,8 +747,8 @@ if (f) {
       ],
     },
     {
-      code: `switch(x) { case 1: \nbar(); }\n `,
-      output: `switch(x) \n{\n case 1: \nbar(); \n}\n `,
+      code: 'switch(x) { case 1: \nbar(); }\n ',
+      output: 'switch(x) \n{\n case 1: \nbar(); \n}\n ',
       options: ['allman'],
       errors: [
         { messageId: 'sameLineOpen', line: 1 },
@@ -748,8 +757,8 @@ if (f) {
       ],
     },
     {
-      code: `if (a) { \nb();\n } else { \nc();\n }`,
-      output: `if (a) \n{ \nb();\n }\n else \n{ \nc();\n }`,
+      code: 'if (a) { \nb();\n } else { \nc();\n }',
+      output: 'if (a) \n{ \nb();\n }\n else \n{ \nc();\n }',
       options: ['allman'],
       errors: [
         { messageId: 'sameLineOpen' },
@@ -758,8 +767,10 @@ if (f) {
       ],
     },
     {
-      code: `if (foo) {\nbaz();\n} else if (bar) {\nbaz();\n}\nelse {\nqux();\n}`,
-      output: `if (foo) \n{\nbaz();\n}\n else if (bar) \n{\nbaz();\n}\nelse \n{\nqux();\n}`,
+      code:
+        'if (foo) {\nbaz();\n} else if (bar) {\nbaz();\n}\nelse {\nqux();\n}',
+      output:
+        'if (foo) \n{\nbaz();\n}\n else if (bar) \n{\nbaz();\n}\nelse \n{\nqux();\n}',
       options: ['allman'],
       errors: [
         { messageId: 'sameLineOpen' },
@@ -769,8 +780,10 @@ if (f) {
       ],
     },
     {
-      code: `if (foo)\n{ poop();\n} \nelse if (bar) {\nbaz();\n} else if (thing) {\nboom();\n}\nelse {\nqux();\n}`,
-      output: `if (foo)\n{\n poop();\n} \nelse if (bar) \n{\nbaz();\n}\n else if (thing) \n{\nboom();\n}\nelse \n{\nqux();\n}`,
+      code:
+        'if (foo)\n{ poop();\n} \nelse if (bar) {\nbaz();\n} else if (thing) {\nboom();\n}\nelse {\nqux();\n}',
+      output:
+        'if (foo)\n{\n poop();\n} \nelse if (bar) \n{\nbaz();\n}\n else if (thing) \n{\nboom();\n}\nelse \n{\nqux();\n}',
       options: ['allman'],
       errors: [
         { messageId: 'blockSameLine' },
@@ -781,159 +794,162 @@ if (f) {
       ],
     },
     {
-      code: `if (foo)\n{\n  bar(); }`,
-      output: `if (foo)\n{\n  bar(); \n}`,
+      code: 'if (foo)\n{\n  bar(); }',
+      output: 'if (foo)\n{\n  bar(); \n}',
       options: ['allman'],
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `try\n{\n  somethingRisky();\n} catch (e)\n{\n  handleError()\n}`,
-      output: `try\n{\n  somethingRisky();\n}\n catch (e)\n{\n  handleError()\n}`,
+      code: 'try\n{\n  somethingRisky();\n} catch (e)\n{\n  handleError()\n}',
+      output:
+        'try\n{\n  somethingRisky();\n}\n catch (e)\n{\n  handleError()\n}',
       options: ['allman'],
       errors: [{ messageId: 'sameLineClose' }],
     },
     // allowSingleLine: true
     {
-      code: `function foo() { return; \n}`,
-      output: `function foo() {\n return; \n}`,
+      code: 'function foo() { return; \n}',
+      output: 'function foo() {\n return; \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'blockSameLine' }],
     },
     {
-      code: `function foo() { a(); b(); return; \n}`,
-      output: `function foo() {\n a(); b(); return; \n}`,
+      code: 'function foo() { a(); b(); return; \n}',
+      output: 'function foo() {\n a(); b(); return; \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'blockSameLine' }],
     },
     {
-      code: `function foo() { \n return; }`,
-      output: `function foo() { \n return; \n}`,
+      code: 'function foo() { \n return; }',
+      output: 'function foo() { \n return; \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `function foo() {\na();\nb();\nreturn; }`,
-      output: `function foo() {\na();\nb();\nreturn; \n}`,
+      code: 'function foo() {\na();\nb();\nreturn; }',
+      output: 'function foo() {\na();\nb();\nreturn; \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `!function foo() { \n return; }`,
-      output: `!function foo() { \n return; \n}`,
+      code: '!function foo() { \n return; }',
+      output: '!function foo() { \n return; \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `if (a) { b();\n } else { c(); }`,
-      output: `if (a) {\n b();\n } else { c(); }`,
+      code: 'if (a) { b();\n } else { c(); }',
+      output: 'if (a) {\n b();\n } else { c(); }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'blockSameLine' }],
     },
     {
-      code: `if (a) { b(); }\nelse { c(); }`,
-      output: `if (a) { b(); } else { c(); }`,
+      code: 'if (a) { b(); }\nelse { c(); }',
+      output: 'if (a) { b(); } else { c(); }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `while (foo) { \n bar(); }`,
-      output: `while (foo) { \n bar(); \n}`,
+      code: 'while (foo) { \n bar(); }',
+      output: 'while (foo) { \n bar(); \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `for (;;) { bar(); \n }`,
-      output: `for (;;) {\n bar(); \n }`,
+      code: 'for (;;) { bar(); \n }',
+      output: 'for (;;) {\n bar(); \n }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'blockSameLine' }],
     },
     {
-      code: `with (foo) { bar(); \n }`,
-      output: `with (foo) {\n bar(); \n }`,
+      code: 'with (foo) { bar(); \n }',
+      output: 'with (foo) {\n bar(); \n }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'blockSameLine' }],
     },
     {
-      code: `switch (foo) \n { \n case \`bar\`: break; }`,
-      output: `switch (foo) { \n case \`bar\`: break; \n}`,
+      code: 'switch (foo) \n { \n case `bar`: break; }',
+      output: 'switch (foo) { \n case `bar`: break; \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineOpen' }, { messageId: 'singleLineClose' }],
     },
     {
-      code: `switch (foo) \n { }`,
-      output: `switch (foo) { }`,
+      code: 'switch (foo) \n { }',
+      output: 'switch (foo) { }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `try {  bar(); }\ncatch (e) { baz();  }`,
-      output: `try {  bar(); } catch (e) { baz();  }`,
+      code: 'try {  bar(); }\ncatch (e) { baz();  }',
+      output: 'try {  bar(); } catch (e) { baz();  }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `try \n { \n bar(); \n } catch (e) {}`,
-      output: `try { \n bar(); \n } catch (e) {}`,
+      code: 'try \n { \n bar(); \n } catch (e) {}',
+      output: 'try { \n bar(); \n } catch (e) {}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `try { \n bar(); \n } catch (e) \n {}`,
-      output: `try { \n bar(); \n } catch (e) {}`,
+      code: 'try { \n bar(); \n } catch (e) \n {}',
+      output: 'try { \n bar(); \n } catch (e) {}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `do \n { \n bar(); \n} while (true)`,
-      output: `do { \n bar(); \n} while (true)`,
+      code: 'do \n { \n bar(); \n} while (true)',
+      output: 'do { \n bar(); \n} while (true)',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `for (foo in bar) \n { \n baz(); \n }`,
-      output: `for (foo in bar) { \n baz(); \n }`,
+      code: 'for (foo in bar) \n { \n baz(); \n }',
+      output: 'for (foo in bar) { \n baz(); \n }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `try { \n bar(); \n }\ncatch (e) {\n}`,
-      output: `try { \n bar(); \n } catch (e) {\n}`,
+      code: 'try { \n bar(); \n }\ncatch (e) {\n}',
+      output: 'try { \n bar(); \n } catch (e) {\n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `try { \n bar(); \n } catch (e) {\n}\n finally {\n}`,
-      output: `try { \n bar(); \n } catch (e) {\n} finally {\n}`,
+      code: 'try { \n bar(); \n } catch (e) {\n}\n finally {\n}',
+      output: 'try { \n bar(); \n } catch (e) {\n} finally {\n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `if (a) { \nb();\n } \n else { \nc();\n }`,
-      output: `if (a) { \nb();\n } else { \nc();\n }`,
+      code: 'if (a) { \nb();\n } \n else { \nc();\n }',
+      output: 'if (a) { \nb();\n } else { \nc();\n }',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'nextLineClose' }],
     },
     {
-      code: `try { \n bar(); \n }\ncatch (e) {\n} finally {\n}`,
-      output: `try { \n bar(); \n }\ncatch (e) {\n}\n finally {\n}`,
+      code: 'try { \n bar(); \n }\ncatch (e) {\n} finally {\n}',
+      output: 'try { \n bar(); \n }\ncatch (e) {\n}\n finally {\n}',
       options: ['stroustrup', { allowSingleLine: true }],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `try { \n bar(); \n } catch (e) {\n}\n finally {\n}`,
-      output: `try { \n bar(); \n }\n catch (e) {\n}\n finally {\n}`,
+      code: 'try { \n bar(); \n } catch (e) {\n}\n finally {\n}',
+      output: 'try { \n bar(); \n }\n catch (e) {\n}\n finally {\n}',
       options: ['stroustrup', { allowSingleLine: true }],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `if (a) { \nb();\n } else { \nc();\n }`,
-      output: `if (a) { \nb();\n }\n else { \nc();\n }`,
+      code: 'if (a) { \nb();\n } else { \nc();\n }',
+      output: 'if (a) { \nb();\n }\n else { \nc();\n }',
       options: ['stroustrup', { allowSingleLine: true }],
       errors: [{ messageId: 'sameLineClose' }],
     },
     {
-      code: `if (foo)\n{ poop();\n} \nelse if (bar) {\nbaz();\n} else if (thing) {\nboom();\n}\nelse {\nqux();\n}`,
-      output: `if (foo)\n{\n poop();\n} \nelse if (bar) \n{\nbaz();\n}\n else if (thing) \n{\nboom();\n}\nelse \n{\nqux();\n}`,
+      code:
+        'if (foo)\n{ poop();\n} \nelse if (bar) {\nbaz();\n} else if (thing) {\nboom();\n}\nelse {\nqux();\n}',
+      output:
+        'if (foo)\n{\n poop();\n} \nelse if (bar) \n{\nbaz();\n}\n else if (thing) \n{\nboom();\n}\nelse \n{\nqux();\n}',
       options: ['allman', { allowSingleLine: true }],
       errors: [
         { messageId: 'blockSameLine' },
@@ -945,25 +961,25 @@ if (f) {
     },
     // Comment interferes with fix
     {
-      code: `if (foo) // comment \n{\nbar();\n}`,
+      code: 'if (foo) // comment \n{\nbar();\n}',
       output: null,
       errors: [{ messageId: 'nextLineOpen' }],
     },
     // https://github.com/eslint/eslint/issues/7493
     {
-      code: `if (foo) {\n bar\n.baz }`,
-      output: `if (foo) {\n bar\n.baz \n}`,
+      code: 'if (foo) {\n bar\n.baz }',
+      output: 'if (foo) {\n bar\n.baz \n}',
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `if (foo)\n{\n bar\n.baz }`,
-      output: `if (foo)\n{\n bar\n.baz \n}`,
+      code: 'if (foo)\n{\n bar\n.baz }',
+      output: 'if (foo)\n{\n bar\n.baz \n}',
       options: ['allman'],
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `if (foo) { bar\n.baz }`,
-      output: `if (foo) {\n bar\n.baz \n}`,
+      code: 'if (foo) { bar\n.baz }',
+      output: 'if (foo) {\n bar\n.baz \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [
         { messageId: 'blockSameLine' },
@@ -971,8 +987,8 @@ if (f) {
       ],
     },
     {
-      code: `if (foo) { bar\n.baz }`,
-      output: `if (foo) \n{\n bar\n.baz \n}`,
+      code: 'if (foo) { bar\n.baz }',
+      output: 'if (foo) \n{\n bar\n.baz \n}',
       options: ['allman', { allowSingleLine: true }],
       errors: [
         { messageId: 'sameLineOpen' },
@@ -981,46 +997,46 @@ if (f) {
       ],
     },
     {
-      code: `switch (x) {\n case 1: foo() }`,
-      output: `switch (x) {\n case 1: foo() \n}`,
+      code: 'switch (x) {\n case 1: foo() }',
+      output: 'switch (x) {\n case 1: foo() \n}',
       options: ['1tbs', { allowSingleLine: true }],
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `class Foo\n{\n}`,
-      output: `class Foo {\n}`,
+      code: 'class Foo\n{\n}',
+      output: 'class Foo {\n}',
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `(class\n{\n})`,
-      output: `(class {\n})`,
+      code: '(class\n{\n})',
+      output: '(class {\n})',
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `class Foo{\n}`,
-      output: `class Foo\n{\n}`,
+      code: 'class Foo{\n}',
+      output: 'class Foo\n{\n}',
       options: ['allman'],
       errors: [{ messageId: 'sameLineOpen' }],
     },
     {
-      code: `(class {\n})`,
-      output: `(class \n{\n})`,
+      code: '(class {\n})',
+      output: '(class \n{\n})',
       options: ['allman'],
       errors: [{ messageId: 'sameLineOpen' }],
     },
     {
-      code: `class Foo {\nbar() {\n}}`,
-      output: `class Foo {\nbar() {\n}\n}`,
+      code: 'class Foo {\nbar() {\n}}',
+      output: 'class Foo {\nbar() {\n}\n}',
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `(class Foo {\nbar() {\n}})`,
-      output: `(class Foo {\nbar() {\n}\n})`,
+      code: '(class Foo {\nbar() {\n}})',
+      output: '(class Foo {\nbar() {\n}\n})',
       errors: [{ messageId: 'singleLineClose' }],
     },
     {
-      code: `class\nFoo{}`,
-      output: `class\nFoo\n{}`,
+      code: 'class\nFoo{}',
+      output: 'class\nFoo\n{}',
       options: ['allman'],
       errors: [{ messageId: 'sameLineOpen' }],
     },
@@ -1070,8 +1086,8 @@ interface Foo {
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `interface Foo { \n }`,
-      output: `interface Foo \n{ \n }`,
+      code: 'interface Foo { \n }',
+      output: 'interface Foo \n{ \n }',
       options: ['allman'],
       errors: [{ messageId: 'sameLineOpen' }],
     },
@@ -1101,8 +1117,8 @@ module "Foo" {
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `module "Foo" { \n }`,
-      output: `module "Foo" \n{ \n }`,
+      code: 'module "Foo" { \n }',
+      output: 'module "Foo" \n{ \n }',
       options: ['allman'],
       errors: [{ messageId: 'sameLineOpen' }],
     },
@@ -1132,8 +1148,8 @@ namespace Foo {
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `namespace Foo { \n }`,
-      output: `namespace Foo \n{ \n }`,
+      code: 'namespace Foo { \n }',
+      output: 'namespace Foo \n{ \n }',
       options: ['allman'],
       errors: [{ messageId: 'sameLineOpen' }],
     },
@@ -1163,8 +1179,8 @@ enum Foo {
       errors: [{ messageId: 'nextLineOpen' }],
     },
     {
-      code: `enum Foo { A }`,
-      output: `enum Foo \n{\n A \n}`,
+      code: 'enum Foo { A }',
+      output: 'enum Foo \n{\n A \n}',
       options: ['allman'],
       errors: [
         { messageId: 'sameLineOpen' },
diff --git a/packages/eslint-plugin/tests/rules/camelcase.test.ts b/packages/eslint-plugin/tests/rules/camelcase.test.ts
index 617cdf3e40f..1a35ee87cc8 100644
--- a/packages/eslint-plugin/tests/rules/camelcase.test.ts
+++ b/packages/eslint-plugin/tests/rules/camelcase.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/camelcase';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -8,75 +8,147 @@ const ruleTester = new RuleTester({
 ruleTester.run('camelcase', rule, {
   valid: [
     {
-      code: 'interface Foo { b_ar: number }',
+      code: `
+interface Foo {
+  b_ar: number;
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'interface Foo { bar: number }',
+      code: `
+interface Foo {
+  bar: number;
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'class Foo { b_ar: number; }',
+      code: `
+class Foo {
+  b_ar: number;
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'class Foo { bar: number; }',
+      code: `
+class Foo {
+  bar: number;
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'class Foo { b_ar: number = 0; }',
+      code: `
+class Foo {
+  b_ar: number = 0;
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'class Foo { bar: number = 0; }',
+      code: `
+class Foo {
+  bar: number = 0;
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'class Foo { constructor(private b_ar: number) {} }',
+      code: `
+class Foo {
+  constructor(private b_ar: number) {}
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'class Foo { constructor(private bar: number) {} }',
+      code: `
+class Foo {
+  constructor(private bar: number) {}
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'class Foo { constructor(private b_ar: number = 0) {} }',
+      code: `
+class Foo {
+  constructor(private b_ar: number = 0) {}
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'class Foo { constructor(private bar: number = 0) {} }',
+      code: `
+class Foo {
+  constructor(private bar: number = 0) {}
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'abstract class Foo { b_ar: number; }',
+      code: `
+abstract class Foo {
+  b_ar: number;
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'abstract class Foo { bar: number; }',
+      code: `
+abstract class Foo {
+  bar: number;
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'abstract class Foo { b_ar: number = 0; }',
+      code: `
+abstract class Foo {
+  b_ar: number = 0;
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'abstract class Foo { bar: number = 0; }',
+      code: `
+abstract class Foo {
+  bar: number = 0;
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'abstract class Foo { abstract b_ar: number; }',
+      code: `
+abstract class Foo {
+  abstract b_ar: number;
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'abstract class Foo { abstract bar: number; }',
+      code: `
+abstract class Foo {
+  abstract bar: number;
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
-      code: 'abstract class Foo { abstract b_ar: number = 0; }',
+      code: `
+abstract class Foo {
+  abstract b_ar: number = 0;
+}
+      `,
       options: [{ properties: 'never' }],
     },
     {
-      code: 'abstract class Foo { abstract bar: number = 0; }',
+      code: `
+abstract class Foo {
+  abstract bar: number = 0;
+}
+      `,
       options: [{ properties: 'always' }],
     },
     {
@@ -141,19 +213,19 @@ class Foo {
     },
     {
       code: `
-type Foo<T> = {}
+type Foo<T> = {};
       `,
       options: [{ genericType: 'always' }],
     },
     {
       code: `
-type Foo<t> = {}
+type Foo<t> = {};
       `,
       options: [{ genericType: 'always' }],
     },
     {
       code: `
-type Foo<t_object> = {}
+type Foo<t_object> = {};
       `,
       options: [{ genericType: 'never' }],
     },
@@ -183,7 +255,7 @@ class Foo {
       code: 'const foo = foo.bar?.foo_bar_baz;',
     },
     {
-      code: 'const foo = (foo?.bar?.baz)?.foo_bar_baz;',
+      code: noFormat`const foo = (foo?.bar?.baz)?.foo_bar_baz;`,
     },
     {
       code: 'const foo = foo_bar?.foo;',
@@ -193,7 +265,11 @@ class Foo {
 
   invalid: [
     {
-      code: 'interface Foo { b_ar: number }',
+      code: `
+interface Foo {
+  b_ar: number;
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -201,13 +277,17 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 17,
+          line: 3,
+          column: 3,
         },
       ],
     },
     {
-      code: 'class Foo { b_ar: number; }',
+      code: `
+class Foo {
+  b_ar: number;
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -215,13 +295,17 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 13,
+          line: 3,
+          column: 3,
         },
       ],
     },
     {
-      code: 'class Foo { constructor(private b_ar: number) {} }',
+      code: `
+class Foo {
+  constructor(private b_ar: number) {}
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -229,13 +313,17 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 33,
+          line: 3,
+          column: 23,
         },
       ],
     },
     {
-      code: 'class Foo { constructor(private b_ar: number = 0) {} }',
+      code: `
+class Foo {
+  constructor(private b_ar: number = 0) {}
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -243,13 +331,17 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 33,
+          line: 3,
+          column: 23,
         },
       ],
     },
     {
-      code: 'abstract class Foo { b_ar: number; }',
+      code: `
+abstract class Foo {
+  b_ar: number;
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -257,13 +349,17 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 22,
+          line: 3,
+          column: 3,
         },
       ],
     },
     {
-      code: 'abstract class Foo { b_ar: number = 0; }',
+      code: `
+abstract class Foo {
+  b_ar: number = 0;
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -271,13 +367,17 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 22,
+          line: 3,
+          column: 3,
         },
       ],
     },
     {
-      code: 'abstract class Foo { abstract b_ar: number; }',
+      code: `
+abstract class Foo {
+  abstract b_ar: number;
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -285,13 +385,17 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 31,
+          line: 3,
+          column: 12,
         },
       ],
     },
     {
-      code: 'abstract class Foo { abstract b_ar: number = 0; }',
+      code: `
+abstract class Foo {
+  abstract b_ar: number = 0;
+}
+      `,
       options: [{ properties: 'always' }],
       errors: [
         {
@@ -299,8 +403,8 @@ class Foo {
           data: {
             name: 'b_ar',
           },
-          line: 1,
-          column: 31,
+          line: 3,
+          column: 12,
         },
       ],
     },
@@ -319,7 +423,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (foo_test?.bar)?.baz;',
+      code: noFormat`const foo = (foo_test?.bar)?.baz;`,
       options: [{ properties: 'always' }],
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts b/packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts
index f0c5f2afc05..19d5fb183b5 100644
--- a/packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/class-literal-property-style.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/class-literal-property-style';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -7,18 +7,50 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('class-literal-property-style', rule, {
   valid: [
-    'class Mx { declare readonly p1 = 1; }',
-    'class Mx { readonly p1 = "hello world"; }',
-    'class Mx { p1 = "hello world"; }',
-    'class Mx { static p1 = "hello world"; }',
-    'class Mx { p1: string; }',
-    'class Mx { get p1(); }',
-    'class Mx { get p1() {} }',
-    'abstract class Mx { abstract get p1(): string }',
+    `
+class Mx {
+  declare readonly p1 = 1;
+}
+    `,
+    `
+class Mx {
+  readonly p1 = 'hello world';
+}
+    `,
+    `
+class Mx {
+  p1 = 'hello world';
+}
+    `,
+    `
+class Mx {
+  static p1 = 'hello world';
+}
+    `,
+    `
+class Mx {
+  p1: string;
+}
+    `,
+    `
+class Mx {
+  get p1();
+}
+    `,
+    `
+class Mx {
+  get p1() {}
+}
+    `,
+    `
+abstract class Mx {
+  abstract get p1(): string;
+}
+    `,
     `
       class Mx {
         get mySetting() {
-          if(this._aValue) {
+          if (this._aValue) {
             return 'on';
           }
 
@@ -29,14 +61,14 @@ ruleTester.run('class-literal-property-style', rule, {
     `
       class Mx {
         get mySetting() {
-          return \`build-\${process.env.build}\`
+          return \`build-\${process.env.build}\`;
         }
       }
     `,
     `
       class Mx {
         getMySetting() {
-          if(this._aValue) {
+          if (this._aValue) {
             return 'on';
           }
 
@@ -64,31 +96,63 @@ ruleTester.run('class-literal-property-style', rule, {
       options: ['fields'],
     },
     {
-      code: 'class Mx { declare public readonly foo = 1; }',
+      code: `
+class Mx {
+  public declare readonly foo = 1;
+}
+      `,
       options: ['getters'],
     },
     {
-      code: 'class Mx { get p1() { return "hello world"; } }',
+      code: `
+class Mx {
+  get p1() {
+    return 'hello world';
+  }
+}
+      `,
       options: ['getters'],
     },
     {
-      code: 'class Mx { p1 = "hello world"; }',
+      code: `
+class Mx {
+  p1 = 'hello world';
+}
+      `,
       options: ['getters'],
     },
     {
-      code: 'class Mx { p1: string; }',
+      code: `
+class Mx {
+  p1: string;
+}
+      `,
       options: ['getters'],
     },
     {
-      code: 'class Mx { readonly p1 = [1, 2, 3]; }',
+      code: `
+class Mx {
+  readonly p1 = [1, 2, 3];
+}
+      `,
       options: ['getters'],
     },
     {
-      code: 'class Mx { static p1: string; }',
+      code: `
+class Mx {
+  static p1: string;
+}
+      `,
       options: ['getters'],
     },
     {
-      code: 'class Mx { static get p1() { return "hello world"; } }',
+      code: `
+class Mx {
+  static get p1() {
+    return 'hello world';
+  }
+}
+      `,
       options: ['getters'],
     },
     {
@@ -116,259 +180,358 @@ ruleTester.run('class-literal-property-style', rule, {
   ],
   invalid: [
     {
-      code: 'class Mx { get p1() { return "hello world"; } }',
-      output: 'class Mx { readonly p1 = "hello world"; }',
+      code: `
+class Mx {
+  get p1() {
+    return 'hello world';
+  }
+}
+      `,
+      output: `
+class Mx {
+  readonly p1 = 'hello world';
+}
+      `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 16,
-          line: 1,
+          column: 7,
+          line: 3,
         },
       ],
     },
     {
-      code: 'class Mx { get p1() { return `hello world`; } }',
-      output: 'class Mx { readonly p1 = `hello world`; }',
+      code: `
+class Mx {
+  get p1() {
+    return \`hello world\`;
+  }
+}
+      `,
+      output: `
+class Mx {
+  readonly p1 = \`hello world\`;
+}
+      `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 16,
-          line: 1,
+          column: 7,
+          line: 3,
         },
       ],
     },
     {
-      code: 'class Mx { static get p1() { return "hello world"; } }',
-      output: 'class Mx { static readonly p1 = "hello world"; }',
+      code: `
+class Mx {
+  static get p1() {
+    return 'hello world';
+  }
+}
+      `,
+      output: `
+class Mx {
+  static readonly p1 = 'hello world';
+}
+      `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 23,
-          line: 1,
+          column: 14,
+          line: 3,
         },
       ],
     },
     {
-      code:
-        'class Mx { public static readonly static private public protected get foo() { return 1; } }',
-      output: 'class Mx { public static readonly foo = 1; }',
+      code: `
+class Mx {
+  public static get foo() {
+    return 1;
+  }
+}
+      `,
+      output: `
+class Mx {
+  public static readonly foo = 1;
+}
+      `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 71,
-          line: 1,
+          column: 21,
+          line: 3,
         },
       ],
     },
     {
       code: `
-        class Mx {
-          public get [myValue]() {
-            return 'a literal value';
-          }
-        }
+class Mx {
+  public get [myValue]() {
+    return 'a literal value';
+  }
+}
       `,
       output: `
-        class Mx {
-          public readonly [myValue] = 'a literal value';
-        }
+class Mx {
+  public readonly [myValue] = 'a literal value';
+}
       `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 23,
+          column: 15,
           line: 3,
         },
       ],
     },
     {
       code: `
-        class Mx {
-          public get [myValue]() {
-            return 12345n;
-          }
-        }
+class Mx {
+  public get [myValue]() {
+    return 12345n;
+  }
+}
       `,
       output: `
-        class Mx {
-          public readonly [myValue] = 12345n;
-        }
+class Mx {
+  public readonly [myValue] = 12345n;
+}
       `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 23,
+          column: 15,
           line: 3,
         },
       ],
     },
     {
       code: `
-        class Mx {
-          public readonly [myValue] = 'a literal value';
-        }
+class Mx {
+  public readonly [myValue] = 'a literal value';
+}
       `,
-      output: `
-        class Mx {
-          public get [myValue]() { return 'a literal value'; }
-        }
+      output: noFormat`
+class Mx {
+  public get [myValue]() { return 'a literal value'; }
+}
       `,
       errors: [
         {
           messageId: 'preferGetterStyle',
-          column: 28,
+          column: 20,
           line: 3,
         },
       ],
       options: ['getters'],
     },
     {
-      code: 'class Mx { readonly p1 = "hello world"; }',
-      output: 'class Mx { get p1() { return "hello world"; } }',
+      code: `
+class Mx {
+  readonly p1 = 'hello world';
+}
+      `,
+      output: noFormat`
+class Mx {
+  get p1() { return 'hello world'; }
+}
+      `,
       errors: [
         {
           messageId: 'preferGetterStyle',
-          column: 21,
-          line: 1,
+          column: 12,
+          line: 3,
         },
       ],
       options: ['getters'],
     },
     {
-      code: 'class Mx { readonly p1 = `hello world`; }',
-      output: 'class Mx { get p1() { return `hello world`; } }',
+      code: `
+class Mx {
+  readonly p1 = \`hello world\`;
+}
+      `,
+      output: noFormat`
+class Mx {
+  get p1() { return \`hello world\`; }
+}
+      `,
       errors: [
         {
           messageId: 'preferGetterStyle',
-          column: 21,
-          line: 1,
+          column: 12,
+          line: 3,
         },
       ],
       options: ['getters'],
     },
     {
-      code: 'class Mx { static readonly p1 = "hello world"; }',
-      output: 'class Mx { static get p1() { return "hello world"; } }',
+      code: `
+class Mx {
+  static readonly p1 = 'hello world';
+}
+      `,
+      output: noFormat`
+class Mx {
+  static get p1() { return 'hello world'; }
+}
+      `,
       errors: [
         {
           messageId: 'preferGetterStyle',
-          column: 28,
-          line: 1,
+          column: 19,
+          line: 3,
         },
       ],
       options: ['getters'],
     },
     {
-      code: 'class Mx { protected get p1() { return "hello world"; } }',
-      output: 'class Mx { protected readonly p1 = "hello world"; }',
+      code: `
+class Mx {
+  protected get p1() {
+    return 'hello world';
+  }
+}
+      `,
+      output: `
+class Mx {
+  protected readonly p1 = 'hello world';
+}
+      `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 26,
-          line: 1,
+          column: 17,
+          line: 3,
         },
       ],
       options: ['fields'],
     },
     {
-      code: 'class Mx { protected readonly p1 = "hello world"; }',
-      output: 'class Mx { protected get p1() { return "hello world"; } }',
+      code: `
+class Mx {
+  protected readonly p1 = 'hello world';
+}
+      `,
+      output: noFormat`
+class Mx {
+  protected get p1() { return 'hello world'; }
+}
+      `,
       errors: [
         {
           messageId: 'preferGetterStyle',
-          column: 31,
-          line: 1,
+          column: 22,
+          line: 3,
         },
       ],
       options: ['getters'],
     },
     {
-      code: 'class Mx { public static get p1() { return "hello world"; } }',
-      output: 'class Mx { public static readonly p1 = "hello world"; }',
+      code: `
+class Mx {
+  public static get p1() {
+    return 'hello world';
+  }
+}
+      `,
+      output: `
+class Mx {
+  public static readonly p1 = 'hello world';
+}
+      `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 30,
-          line: 1,
+          column: 21,
+          line: 3,
         },
       ],
     },
     {
-      code: 'class Mx { public static readonly p1 = "hello world"; }',
-      output: 'class Mx { public static get p1() { return "hello world"; } }',
+      code: `
+class Mx {
+  public static readonly p1 = 'hello world';
+}
+      `,
+      output: noFormat`
+class Mx {
+  public static get p1() { return 'hello world'; }
+}
+      `,
       errors: [
         {
           messageId: 'preferGetterStyle',
-          column: 35,
-          line: 1,
+          column: 26,
+          line: 3,
         },
       ],
       options: ['getters'],
     },
     {
       code: `
-        class Mx {
-          public get myValue() {
-            return gql\`
-              {
-                user(id: 5) {
-                  firstName
-                  lastName
-                }
-              }
-            \`;
-          }
+class Mx {
+  public get myValue() {
+    return gql\`
+      {
+        user(id: 5) {
+          firstName
+          lastName
         }
+      }
+    \`;
+  }
+}
       `,
-      output: `
-        class Mx {
-          public readonly myValue = gql\`
-              {
-                user(id: 5) {
-                  firstName
-                  lastName
-                }
-              }
-            \`;
+      output: noFormat`
+class Mx {
+  public readonly myValue = gql\`
+      {
+        user(id: 5) {
+          firstName
+          lastName
         }
+      }
+    \`;
+}
       `,
       errors: [
         {
           messageId: 'preferFieldStyle',
-          column: 22,
+          column: 14,
           line: 3,
         },
       ],
     },
     {
       code: `
-        class Mx {
-          public readonly myValue = gql\`
-            {
-              user(id: 5) {
-                firstName
-                lastName
-              }
-            }
-          \`;
-        }
+class Mx {
+  public readonly myValue = gql\`
+    {
+      user(id: 5) {
+        firstName
+        lastName
+      }
+    }
+  \`;
+}
       `,
-      output: `
-        class Mx {
-          public get myValue() { return gql\`
-            {
-              user(id: 5) {
-                firstName
-                lastName
-              }
-            }
-          \`; }
-        }
+      output: noFormat`
+class Mx {
+  public get myValue() { return gql\`
+    {
+      user(id: 5) {
+        firstName
+        lastName
+      }
+    }
+  \`; }
+}
       `,
       errors: [
         {
           messageId: 'preferGetterStyle',
-          column: 27,
+          column: 19,
           line: 3,
         },
       ],
diff --git a/packages/eslint-plugin/tests/rules/class-name-casing.test.ts b/packages/eslint-plugin/tests/rules/class-name-casing.test.ts
index 11f6dc8b888..1977a36415d 100644
--- a/packages/eslint-plugin/tests/rules/class-name-casing.test.ts
+++ b/packages/eslint-plugin/tests/rules/class-name-casing.test.ts
@@ -35,12 +35,19 @@ ruleTester.run('class-name-casing', rule, {
     'class ÈClassNameWithUnicode {}',
     'class ClassNameWithæUnicode {}',
     // Following test cases are valid, but no one is going to write code like this
-    'var { bar } = class { static bar() { return 2 } }',
-    `var [ bar ] = class {
-      static [Symbol.iterator]() {
-        return { next: () => ({ value: 1, done: false}) }
-      }
-    }
+    `
+var { bar } = class {
+  static bar() {
+    return 2;
+  }
+};
+    `,
+    `
+var [bar] = class {
+  static [Symbol.iterator]() {
+    return { next: () => ({ value: 1, done: false }) };
+  }
+};
     `,
   ],
 
@@ -116,7 +123,7 @@ ruleTester.run('class-name-casing', rule, {
       ],
     },
     {
-      code: 'var bar = class invalidName {}',
+      code: 'var bar = class invalidName {};',
       errors: [
         {
           messageId: 'notPascalCased',
diff --git a/packages/eslint-plugin/tests/rules/comma-spacing.test.ts b/packages/eslint-plugin/tests/rules/comma-spacing.test.ts
index 12a6e0219f8..7147815b759 100644
--- a/packages/eslint-plugin/tests/rules/comma-spacing.test.ts
+++ b/packages/eslint-plugin/tests/rules/comma-spacing.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the spacing, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import rule from '../../src/rules/comma-spacing';
 import { RuleTester } from '../RuleTester';
 
@@ -7,280 +12,280 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('comma-spacing', rule, {
   valid: [
-    `foo(1, true/* comment */, 'text');`,
-    `foo(1, true /* comment */, 'text');`,
-    `foo(1, true/* comment *//* comment */, 'text');`,
-    `foo(1, true/* comment */ /* comment */, 'text');`,
-    `foo(1, true, /* comment */ 'text');`,
-    `foo(1, // comment\n true, /* comment */ 'text');`,
-    {
-      code: `foo(1, // comment\n true,/* comment */ 'text');`,
+    "foo(1, true/* comment */, 'text');",
+    "foo(1, true /* comment */, 'text');",
+    "foo(1, true/* comment *//* comment */, 'text');",
+    "foo(1, true/* comment */ /* comment */, 'text');",
+    "foo(1, true, /* comment */ 'text');",
+    "foo(1, // comment\n true, /* comment */ 'text');",
+    {
+      code: "foo(1, // comment\n true,/* comment */ 'text');",
       options: [{ before: false, after: false }],
     },
-    `const a = 1, b = 2;`,
-    `const foo = [, ];`,
-    `const foo = [1, ];`,
-    `const foo = [, 2];`,
-    `const foo = [1, 2];`,
-    `const foo = [, , ];`,
-    `const foo = [1, , ];`,
-    `const foo = [, 2, ];`,
-    `const foo = [, , 3];`,
-    `const foo = [1, 2, ];`,
-    `const foo = [, 2, 3];`,
-    `const foo = [1, , 3];`,
-    `const foo = [1, 2, 3];`,
-    `const foo = {'foo':'foo', 'baz':'baz'};`,
-    `const foo = {'foo':'foo', 'baz':\n'baz'};`,
-    `const foo = {'foo':\n'foo', 'baz':\n'baz'};`,
-    `function foo(a, b){}`,
-    `function foo(a, b = 1){}`,
-    `function foo(a = 1, b, c){}`,
-    `const foo = (a, b) => {}`,
-    `const foo = (a=1, b) => {}`,
-    `const foo = a => a + 2`,
-    `a, b`,
-    `const a = (1 + 2, 2)`,
-    `a(b, c)`,
-    `new A(b, c)`,
-    `foo((a), b)`,
-    `const b = ((1 + 2), 2)`,
-    `parseInt((a + b), 10)`,
-    `go.boom((a + b), 10)`,
-    `go.boom((a + b), 10, (4))`,
-    `const x = [ (a + c), (b + b) ]`,
-    `['  ,  ']`,
+    'const a = 1, b = 2;',
+    'const foo = [, ];',
+    'const foo = [1, ];',
+    'const foo = [, 2];',
+    'const foo = [1, 2];',
+    'const foo = [, , ];',
+    'const foo = [1, , ];',
+    'const foo = [, 2, ];',
+    'const foo = [, , 3];',
+    'const foo = [1, 2, ];',
+    'const foo = [, 2, 3];',
+    'const foo = [1, , 3];',
+    'const foo = [1, 2, 3];',
+    "const foo = {'foo':'foo', 'baz':'baz'};",
+    "const foo = {'foo':'foo', 'baz':\n'baz'};",
+    "const foo = {'foo':\n'foo', 'baz':\n'baz'};",
+    'function foo(a, b){}',
+    'function foo(a, b = 1){}',
+    'function foo(a = 1, b, c){}',
+    'const foo = (a, b) => {}',
+    'const foo = (a=1, b) => {}',
+    'const foo = a => a + 2',
+    'a, b',
+    'const a = (1 + 2, 2)',
+    'a(b, c)',
+    'new A(b, c)',
+    'foo((a), b)',
+    'const b = ((1 + 2), 2)',
+    'parseInt((a + b), 10)',
+    'go.boom((a + b), 10)',
+    'go.boom((a + b), 10, (4))',
+    'const x = [ (a + c), (b + b) ]',
+    "['  ,  ']",
     '[`  ,  `]',
     '`${[1, 2]}`',
-    `fn(a, b,)`,
-    `const fn = (a, b,) => {}`,
-    `const fn = function (a, b,) {}`,
-    `foo(/,/, 'a')`,
-    `const x = ',,,,,';`,
-    `const code = 'var foo = 1, bar = 3;'`,
-    `['apples', \n 'oranges'];`,
-    `{x: 'var x,y,z'}`,
-    {
-      code: `const foo = {'foo':\n'bar' ,'baz':\n'qur'};`,
+    'fn(a, b,)',
+    'const fn = (a, b,) => {}',
+    'const fn = function (a, b,) {}',
+    "foo(/,/, 'a')",
+    "const x = ',,,,,';",
+    "const code = 'var foo = 1, bar = 3;'",
+    "['apples', \n 'oranges'];",
+    "{x: 'var x,y,z'}",
+    {
+      code: "const foo = {'foo':\n'bar' ,'baz':\n'qur'};",
       options: [{ before: true, after: false }],
     },
     {
-      code: `const a = 1 ,b = 2;`,
+      code: 'const a = 1 ,b = 2;',
       options: [{ before: true, after: false }],
     },
     {
-      code: `function foo(a ,b){}`,
+      code: 'function foo(a ,b){}',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [,];`,
+      code: 'const arr = [,];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [1 ,];`,
+      code: 'const arr = [1 ,];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [ ,2];`,
+      code: 'const arr = [ ,2];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [1 ,2];`,
+      code: 'const arr = [1 ,2];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [,,];`,
+      code: 'const arr = [,,];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [1 , ,];`,
+      code: 'const arr = [1 , ,];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [ ,2 ,];`,
+      code: 'const arr = [ ,2 ,];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [ , ,3];`,
+      code: 'const arr = [ , ,3];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [1 ,2 ,];`,
+      code: 'const arr = [1 ,2 ,];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [ ,2 ,3];`,
+      code: 'const arr = [ ,2 ,3];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [1 , ,3];`,
+      code: 'const arr = [1 , ,3];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const arr = [1 ,2 ,3];`,
+      code: 'const arr = [1 ,2 ,3];',
       options: [{ before: true, after: false }],
     },
     {
-      code: `const obj = {'foo':'bar' , 'baz':'qur'};`,
+      code: "const obj = {'foo':'bar' , 'baz':'qur'};",
       options: [{ before: true, after: true }],
     },
     {
-      code: `const a = 1 , b = 2;`,
+      code: 'const a = 1 , b = 2;',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [, ];`,
+      code: 'const arr = [, ];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [1 , ];`,
+      code: 'const arr = [1 , ];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [ , 2];`,
+      code: 'const arr = [ , 2];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [1 , 2];`,
+      code: 'const arr = [1 , 2];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [, , ];`,
+      code: 'const arr = [, , ];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [1 , , ];`,
+      code: 'const arr = [1 , , ];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [ , 2 , ];`,
+      code: 'const arr = [ , 2 , ];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [ , , 3];`,
+      code: 'const arr = [ , , 3];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [1 , 2 , ];`,
+      code: 'const arr = [1 , 2 , ];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [, 2 , 3];`,
+      code: 'const arr = [, 2 , 3];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [1 , , 3];`,
+      code: 'const arr = [1 , , 3];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [1 , 2 , 3];`,
+      code: 'const arr = [1 , 2 , 3];',
       options: [{ before: true, after: true }],
     },
     {
-      code: `a , b`,
+      code: 'a , b',
       options: [{ before: true, after: true }],
     },
     {
-      code: `const arr = [,];`,
+      code: 'const arr = [,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [ ,];`,
+      code: 'const arr = [ ,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [1,];`,
+      code: 'const arr = [1,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [,2];`,
+      code: 'const arr = [,2];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [ ,2];`,
+      code: 'const arr = [ ,2];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [1,2];`,
+      code: 'const arr = [1,2];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [,,];`,
+      code: 'const arr = [,,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [ ,,];`,
+      code: 'const arr = [ ,,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [1,,];`,
+      code: 'const arr = [1,,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [,2,];`,
+      code: 'const arr = [,2,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [ ,2,];`,
+      code: 'const arr = [ ,2,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [,,3];`,
+      code: 'const arr = [,,3];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [1,2,];`,
+      code: 'const arr = [1,2,];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [,2,3];`,
+      code: 'const arr = [,2,3];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [1,,3];`,
+      code: 'const arr = [1,,3];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const arr = [1,2,3];`,
+      code: 'const arr = [1,2,3];',
       options: [{ before: false, after: false }],
     },
     {
-      code: `const a = (1 + 2,2)`,
+      code: 'const a = (1 + 2,2)',
       options: [{ before: false, after: false }],
     },
     'const a; console.log(`${a}`, "a");',
-    `const [a, b] = [1, 2];`,
-    `const [a, b, ] = [1, 2];`,
-    `const [a, , b] = [1, 2, 3];`,
-    `const [ , b] = a;`,
-    `const [, b] = a;`,
+    'const [a, b] = [1, 2];',
+    'const [a, b, ] = [1, 2];',
+    'const [a, , b] = [1, 2, 3];',
+    'const [ , b] = a;',
+    'const [, b] = a;',
     {
-      code: `<a>,</a>`,
+      code: '<a>,</a>',
       parserOptions: {
         ecmaFeatures: { jsx: true },
       },
     },
     {
-      code: `<a>  ,  </a>`,
+      code: '<a>  ,  </a>',
       parserOptions: {
         ecmaFeatures: { jsx: true },
       },
     },
     {
-      code: `<a>Hello, world</a>`,
+      code: '<a>Hello, world</a>',
       options: [{ before: true, after: false }],
       parserOptions: { ecmaFeatures: { jsx: true } },
     },
-    `const Foo = <T,>(foo: T) => {}`,
-    `function foo<T,>() {}`,
-    `class Foo<T, T1> {}`,
-    `interface Foo<T, T1,>{}`,
+    'const Foo = <T,>(foo: T) => {}',
+    'function foo<T,>() {}',
+    'class Foo<T, T1> {}',
+    'interface Foo<T, T1,>{}',
   ],
 
   invalid: [
     {
-      code: `a(b,c)`,
-      output: `a(b , c)`,
+      code: 'a(b,c)',
+      output: 'a(b , c)',
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -298,8 +303,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `new A(b,c)`,
-      output: `new A(b , c)`,
+      code: 'new A(b,c)',
+      output: 'new A(b , c)',
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -317,8 +322,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const a = 1 ,b = 2;`,
-      output: `const a = 1, b = 2;`,
+      code: 'const a = 1 ,b = 2;',
+      output: 'const a = 1, b = 2;',
       errors: [
         {
           messageId: 'unexpected',
@@ -335,8 +340,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1 , 2];`,
-      output: `const arr = [1, 2];`,
+      code: 'const arr = [1 , 2];',
+      output: 'const arr = [1, 2];',
       errors: [
         {
           messageId: 'unexpected',
@@ -359,8 +364,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1 , ];`,
-      output: `const arr = [1 ,];`,
+      code: 'const arr = [1 , ];',
+      output: 'const arr = [1 ,];',
       options: [{ before: true, after: false }],
       errors: [
         {
@@ -372,8 +377,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1 ,2];`,
-      output: `const arr = [1, 2];`,
+      code: 'const arr = [1 ,2];',
+      output: 'const arr = [1, 2];',
       errors: [
         {
           messageId: 'unexpected',
@@ -390,8 +395,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [(1) , 2];`,
-      output: `const arr = [(1), 2];`,
+      code: 'const arr = [(1) , 2];',
+      output: 'const arr = [(1), 2];',
       errors: [
         {
           messageId: 'unexpected',
@@ -402,8 +407,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1, 2];`,
-      output: `const arr = [1 ,2];`,
+      code: 'const arr = [1, 2];',
+      output: 'const arr = [1 ,2];',
       options: [{ before: true, after: false }],
       errors: [
         {
@@ -421,8 +426,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1\n  , 2];`,
-      output: `const arr = [1\n  ,2];`,
+      code: 'const arr = [1\n  , 2];',
+      output: 'const arr = [1\n  ,2];',
       options: [{ before: false, after: false }],
       errors: [
         {
@@ -434,8 +439,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1,\n  2];`,
-      output: `const arr = [1 ,\n  2];`,
+      code: 'const arr = [1,\n  2];',
+      output: 'const arr = [1 ,\n  2];',
       options: [{ before: true, after: false }],
       errors: [
         {
@@ -447,8 +452,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const obj = {'foo':\n'bar', 'baz':\n'qur'};`,
-      output: `const obj = {'foo':\n'bar' ,'baz':\n'qur'};`,
+      code: "const obj = {'foo':\n'bar', 'baz':\n'qur'};",
+      output: "const obj = {'foo':\n'bar' ,'baz':\n'qur'};",
       options: [{ before: true, after: false }],
       errors: [
         {
@@ -466,8 +471,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const obj = {a: 1\n  ,b: 2};`,
-      output: `const obj = {a: 1\n  , b: 2};`,
+      code: 'const obj = {a: 1\n  ,b: 2};',
+      output: 'const obj = {a: 1\n  , b: 2};',
       options: [{ before: false, after: true }],
       errors: [
         {
@@ -479,8 +484,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const obj = {a: 1 ,\n  b: 2};`,
-      output: `const obj = {a: 1,\n  b: 2};`,
+      code: 'const obj = {a: 1 ,\n  b: 2};',
+      output: 'const obj = {a: 1,\n  b: 2};',
       options: [{ before: false, after: false }],
       errors: [
         {
@@ -492,8 +497,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1 ,2];`,
-      output: `const arr = [1 , 2];`,
+      code: 'const arr = [1 ,2];',
+      output: 'const arr = [1 , 2];',
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -505,8 +510,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1,2];`,
-      output: `const arr = [1 , 2];`,
+      code: 'const arr = [1,2];',
+      output: 'const arr = [1 , 2];',
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -524,8 +529,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const obj = {'foo':\n'bar','baz':\n'qur'};`,
-      output: `const obj = {'foo':\n'bar' , 'baz':\n'qur'};`,
+      code: "const obj = {'foo':\n'bar','baz':\n'qur'};",
+      output: "const obj = {'foo':\n'bar' , 'baz':\n'qur'};",
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -543,8 +548,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const arr = [1 , 2];`,
-      output: `const arr = [1,2];`,
+      code: 'const arr = [1 , 2];',
+      output: 'const arr = [1,2];',
       options: [{ before: false, after: false }],
       errors: [
         {
@@ -562,8 +567,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `a ,b`,
-      output: `a, b`,
+      code: 'a ,b',
+      output: 'a, b',
       options: [{ before: false, after: true }],
       errors: [
         {
@@ -581,8 +586,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `function foo(a,b){}`,
-      output: `function foo(a , b){}`,
+      code: 'function foo(a,b){}',
+      output: 'function foo(a , b){}',
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -600,8 +605,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const foo = (a,b) => {}`,
-      output: `const foo = (a , b) => {}`,
+      code: 'const foo = (a,b) => {}',
+      output: 'const foo = (a , b) => {}',
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -619,8 +624,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `const foo = (a = 1,b) => {}`,
-      output: `const foo = (a = 1 , b) => {}`,
+      code: 'const foo = (a = 1,b) => {}',
+      output: 'const foo = (a = 1 , b) => {}',
       options: [{ before: true, after: true }],
       errors: [
         {
@@ -638,8 +643,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `function foo(a = 1 ,b = 2) {}`,
-      output: `function foo(a = 1, b = 2) {}`,
+      code: 'function foo(a = 1 ,b = 2) {}',
+      output: 'function foo(a = 1, b = 2) {}',
       options: [{ before: false, after: true }],
       errors: [
         {
@@ -657,8 +662,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `<a>{foo(1 ,2)}</a>`,
-      output: `<a>{foo(1, 2)}</a>`,
+      code: '<a>{foo(1 ,2)}</a>',
+      output: '<a>{foo(1, 2)}</a>',
       parserOptions: {
         ecmaFeatures: { jsx: true },
       },
@@ -678,8 +683,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `foo(1, true/* comment */ , 'foo');`,
-      output: `foo(1, true/* comment */, 'foo');`,
+      code: "foo(1, true/* comment */ , 'foo');",
+      output: "foo(1, true/* comment */, 'foo');",
       errors: [
         {
           messageId: 'unexpected',
@@ -690,8 +695,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `foo(1, true,/* comment */ 'foo');`,
-      output: `foo(1, true, /* comment */ 'foo');`,
+      code: "foo(1, true,/* comment */ 'foo');",
+      output: "foo(1, true, /* comment */ 'foo');",
       errors: [
         {
           messageId: 'missing',
@@ -702,8 +707,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `foo(404,// comment\n true, 'hello');`,
-      output: `foo(404, // comment\n true, 'hello');`,
+      code: "foo(404,// comment\n true, 'hello');",
+      output: "foo(404, // comment\n true, 'hello');",
       errors: [
         {
           messageId: 'missing',
@@ -714,8 +719,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `function Foo<T,T1>() {}`,
-      output: `function Foo<T, T1>() {}`,
+      code: 'function Foo<T,T1>() {}',
+      output: 'function Foo<T, T1>() {}',
       errors: [
         {
           messageId: 'missing',
@@ -726,8 +731,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `function Foo<T , T1>() {}`,
-      output: `function Foo<T, T1>() {}`,
+      code: 'function Foo<T , T1>() {}',
+      output: 'function Foo<T, T1>() {}',
       errors: [
         {
           messageId: 'unexpected',
@@ -738,8 +743,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `function Foo<T ,T1>() {}`,
-      output: `function Foo<T, T1>() {}`,
+      code: 'function Foo<T ,T1>() {}',
+      output: 'function Foo<T, T1>() {}',
       errors: [
         {
           messageId: 'unexpected',
@@ -756,8 +761,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `function Foo<T, T1>() {}`,
-      output: `function Foo<T,T1>() {}`,
+      code: 'function Foo<T, T1>() {}',
+      output: 'function Foo<T,T1>() {}',
       options: [{ before: false, after: false }],
       errors: [
         {
@@ -769,8 +774,8 @@ ruleTester.run('comma-spacing', rule, {
       ],
     },
     {
-      code: `function Foo<T,T1>() {}`,
-      output: `function Foo<T ,T1>() {}`,
+      code: 'function Foo<T,T1>() {}',
+      output: 'function Foo<T ,T1>() {}',
       options: [{ before: true, after: false }],
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts b/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
index b777a1fc68f..78e5d3ceb01 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-definitions.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/consistent-type-definitions';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -8,58 +8,62 @@ const ruleTester = new RuleTester({
 ruleTester.run('consistent-type-definitions', rule, {
   valid: [
     {
-      code: `var foo = { };`,
+      code: 'var foo = {};',
       options: ['interface'],
     },
     {
-      code: `interface A {}`,
+      code: 'interface A {}',
       options: ['interface'],
     },
     {
-      code: `interface A extends B { x: number; }`,
+      code: `
+interface A extends B {
+  x: number;
+}
+      `,
       options: ['interface'],
     },
     {
-      code: `type U = string;`,
+      code: 'type U = string;',
       options: ['interface'],
     },
     {
-      code: `type V = { x: number; } | { y: string; };`,
+      code: 'type V = { x: number } | { y: string };',
       options: ['interface'],
     },
     {
       code: `
 type Record<T, U> = {
-    [K in T]: U;
-}
-`,
+  [K in T]: U;
+};
+      `,
       options: ['interface'],
     },
     {
-      code: `type T = { x: number; }`,
+      code: 'type T = { x: number };',
       options: ['type'],
     },
     {
-      code: `type A = { x: number; } & B & C;`,
+      code: 'type A = { x: number } & B & C;',
       options: ['type'],
     },
     {
-      code: `type A = { x: number; } & B<T1> & C<T2>;`,
+      code: 'type A = { x: number } & B<T1> & C<T2>;',
       options: ['type'],
     },
     {
       code: `
 export type W<T> = {
-    x: T,
+  x: T;
 };
-`,
+      `,
       options: ['type'],
     },
   ],
   invalid: [
     {
-      code: `type T = { x: number; };`,
-      output: `interface T { x: number; }`,
+      code: noFormat`type T = { x: number; };`,
+      output: noFormat`interface T { x: number; }`,
       options: ['interface'],
       errors: [
         {
@@ -70,8 +74,8 @@ export type W<T> = {
       ],
     },
     {
-      code: `type T={ x: number; };`,
-      output: `interface T { x: number; }`,
+      code: noFormat`type T={ x: number; };`,
+      output: noFormat`interface T { x: number; }`,
       options: ['interface'],
       errors: [
         {
@@ -82,8 +86,8 @@ export type W<T> = {
       ],
     },
     {
-      code: `type T=                         { x: number; };`,
-      output: `interface T { x: number; }`,
+      code: noFormat`type T=                         { x: number; };`,
+      output: noFormat`interface T { x: number; }`,
       options: ['interface'],
       errors: [
         {
@@ -96,14 +100,14 @@ export type W<T> = {
     {
       code: `
 export type W<T> = {
-    x: T,
+  x: T;
 };
-`,
+      `,
       output: `
 export interface W<T> {
-    x: T,
+  x: T;
 }
-`,
+      `,
       options: ['interface'],
       errors: [
         {
@@ -114,8 +118,8 @@ export interface W<T> {
       ],
     },
     {
-      code: `interface T { x: number; }`,
-      output: `type T = { x: number; }`,
+      code: noFormat`interface T { x: number; }`,
+      output: noFormat`type T = { x: number; }`,
       options: ['type'],
       errors: [
         {
@@ -126,8 +130,8 @@ export interface W<T> {
       ],
     },
     {
-      code: `interface T{ x: number; }`,
-      output: `type T = { x: number; }`,
+      code: noFormat`interface T{ x: number; }`,
+      output: noFormat`type T = { x: number; }`,
       options: ['type'],
       errors: [
         {
@@ -138,8 +142,8 @@ export interface W<T> {
       ],
     },
     {
-      code: `interface T                          { x: number; }`,
-      output: `type T = { x: number; }`,
+      code: noFormat`interface T                          { x: number; }`,
+      output: noFormat`type T = { x: number; }`,
       options: ['type'],
       errors: [
         {
@@ -150,8 +154,8 @@ export interface W<T> {
       ],
     },
     {
-      code: `interface A extends B, C { x: number; };`,
-      output: `type A = { x: number; } & B & C;`,
+      code: noFormat`interface A extends B, C { x: number; };`,
+      output: noFormat`type A = { x: number; } & B & C;`,
       options: ['type'],
       errors: [
         {
@@ -162,8 +166,8 @@ export interface W<T> {
       ],
     },
     {
-      code: `interface A extends B<T1>, C<T2> { x: number; };`,
-      output: `type A = { x: number; } & B<T1> & C<T2>;`,
+      code: noFormat`interface A extends B<T1>, C<T2> { x: number; };`,
+      output: noFormat`type A = { x: number; } & B<T1> & C<T2>;`,
       options: ['type'],
       errors: [
         {
@@ -176,14 +180,14 @@ export interface W<T> {
     {
       code: `
 export interface W<T> {
-    x: T,
-};
-`,
-      output: `
+  x: T;
+}
+      `,
+      output: noFormat`
 export type W<T> = {
-    x: T,
-};
-`,
+  x: T;
+}
+      `,
       options: ['type'],
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/default-param-last.test.ts b/packages/eslint-plugin/tests/rules/default-param-last.test.ts
index d965df3c77f..76e23bbe8a7 100644
--- a/packages/eslint-plugin/tests/rules/default-param-last.test.ts
+++ b/packages/eslint-plugin/tests/rules/default-param-last.test.ts
@@ -19,29 +19,29 @@ ruleTester.run('default-param-last', rule, {
     'function foo(a: number, b?: number, c = 1) {}',
     'function foo(a: number, b = 1, ...c) {}',
 
-    'const foo = function () {}',
-    'const foo = function (a: number) {}',
-    'const foo = function (a = 1) {}',
-    'const foo = function (a?: number) {}',
-    'const foo = function (a: number, b: number) {}',
-    'const foo = function (a: number, b: number, c?: number) {}',
-    'const foo = function (a: number, b = 1) {}',
-    'const foo = function (a: number, b = 1, c = 1) {}',
-    'const foo = function (a: number, b = 1, c?: number) {}',
-    'const foo = function (a: number, b?: number, c = 1) {}',
-    'const foo = function (a: number, b = 1, ...c) {}',
+    'const foo = function() {};',
+    'const foo = function(a: number) {};',
+    'const foo = function(a = 1) {};',
+    'const foo = function(a?: number) {};',
+    'const foo = function(a: number, b: number) {};',
+    'const foo = function(a: number, b: number, c?: number) {};',
+    'const foo = function(a: number, b = 1) {};',
+    'const foo = function(a: number, b = 1, c = 1) {};',
+    'const foo = function(a: number, b = 1, c?: number) {};',
+    'const foo = function(a: number, b?: number, c = 1) {};',
+    'const foo = function(a: number, b = 1, ...c) {};',
 
-    'const foo = () => {}',
-    'const foo = (a: number) => {}',
-    'const foo = (a = 1) => {}',
-    'const foo = (a?: number) => {}',
-    'const foo = (a: number, b: number) => {}',
-    'const foo = (a: number, b: number, c?: number) => {}',
-    'const foo = (a: number, b = 1) => {}',
-    'const foo = (a: number, b = 1, c = 1) => {}',
-    'const foo = (a: number, b = 1, c?: number) => {}',
-    'const foo = (a: number, b?: number, c = 1) => {}',
-    'const foo = (a: number, b = 1, ...c) => {}',
+    'const foo = () => {};',
+    'const foo = (a: number) => {};',
+    'const foo = (a = 1) => {};',
+    'const foo = (a?: number) => {};',
+    'const foo = (a: number, b: number) => {};',
+    'const foo = (a: number, b: number, c?: number) => {};',
+    'const foo = (a: number, b = 1) => {};',
+    'const foo = (a: number, b = 1, c = 1) => {};',
+    'const foo = (a: number, b = 1, c?: number) => {};',
+    'const foo = (a: number, b?: number, c = 1) => {};',
+    'const foo = (a: number, b = 1, ...c) => {};',
     `
 class Foo {
   constructor(a: number, b: number, c: number) {}
@@ -251,7 +251,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a = 1, b: number) {}',
+      code: 'const foo = function(a = 1, b: number) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -262,7 +262,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a = 1, b = 2, c: number) {}',
+      code: 'const foo = function(a = 1, b = 2, c: number) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -279,7 +279,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a = 1, b: number, c = 2, d: number) {}',
+      code: 'const foo = function(a = 1, b: number, c = 2, d: number) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -296,7 +296,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a = 1, b: number, c = 2) {}',
+      code: 'const foo = function(a = 1, b: number, c = 2) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -307,7 +307,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a = 1, b: number, ...c) {}',
+      code: 'const foo = function(a = 1, b: number, ...c) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -318,7 +318,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a?: number, b: number) {}',
+      code: 'const foo = function(a?: number, b: number) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -329,7 +329,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a: number, b?: number, c: number) {}',
+      code: 'const foo = function(a: number, b?: number, c: number) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -340,7 +340,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a = 1, b?: number, c: number) {}',
+      code: 'const foo = function(a = 1, b?: number, c: number) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -357,7 +357,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function(a = 1, { b }) {}',
+      code: 'const foo = function(a = 1, { b }) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -368,7 +368,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function({ a } = {}, b) {}',
+      code: 'const foo = function({ a } = {}, b) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -379,7 +379,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function({ a, b } = { a: 1, b: 2 }, c) {}',
+      code: 'const foo = function({ a, b } = { a: 1, b: 2 }, c) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -390,7 +390,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function([a] = [], b) {}',
+      code: 'const foo = function([a] = [], b) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -401,7 +401,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = function([a, b] = [1, 2], c) {}',
+      code: 'const foo = function([a, b] = [1, 2], c) {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -412,7 +412,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a = 1, b: number) => {}',
+      code: 'const foo = (a = 1, b: number) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -423,7 +423,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a = 1, b = 2, c: number) => {}',
+      code: 'const foo = (a = 1, b = 2, c: number) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -440,7 +440,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a = 1, b: number, c = 2, d: number) => {}',
+      code: 'const foo = (a = 1, b: number, c = 2, d: number) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -457,7 +457,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a = 1, b: number, c = 2) => {}',
+      code: 'const foo = (a = 1, b: number, c = 2) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -468,7 +468,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a = 1, b: number, ...c) => {}',
+      code: 'const foo = (a = 1, b: number, ...c) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -479,7 +479,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a?: number, b: number) => {}',
+      code: 'const foo = (a?: number, b: number) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -490,7 +490,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a: number, b?: number, c: number) => {}',
+      code: 'const foo = (a: number, b?: number, c: number) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -501,7 +501,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a = 1, b?: number, c: number) => {}',
+      code: 'const foo = (a = 1, b?: number, c: number) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -518,7 +518,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = (a = 1, { b }) => {}',
+      code: 'const foo = (a = 1, { b }) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -529,7 +529,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = ({ a } = {}, b) => {}',
+      code: 'const foo = ({ a } = {}, b) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -540,7 +540,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = ({ a, b } = { a: 1, b: 2 }, c) => {}',
+      code: 'const foo = ({ a, b } = { a: 1, b: 2 }, c) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -551,7 +551,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = ([a] = [], b) => {}',
+      code: 'const foo = ([a] = [], b) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
@@ -562,7 +562,7 @@ class Foo {
       ],
     },
     {
-      code: 'const foo = ([a, b] = [1, 2], c) => {}',
+      code: 'const foo = ([a, b] = [1, 2], c) => {};',
       errors: [
         {
           messageId: 'shouldBeLast',
diff --git a/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts b/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts
index fb353eec1a3..46ab4944185 100644
--- a/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts
@@ -11,23 +11,23 @@ ruleTester.run('explicit-function-return-type', rule, {
       filename: 'test.ts',
       code: `
 function test(): void {
-    return;
+  return;
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 var fn = function(): number {
-    return 1;
+  return 1;
 };
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 var arrowFn = (): string => 'test';
-            `,
+      `,
     },
     {
       filename: 'test.ts',
@@ -43,11 +43,11 @@ class Test {
   }
   arrow = (): string => 'arrow';
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
-      code: `fn(() => {});`,
+      code: 'fn(() => {});',
       options: [
         {
           allowExpressions: true,
@@ -56,7 +56,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `fn(function() {});`,
+      code: 'fn(function() {});',
       options: [
         {
           allowExpressions: true,
@@ -65,7 +65,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `[function() {}, () => {}]`,
+      code: '[function() {}, () => {}];',
       options: [
         {
           allowExpressions: true,
@@ -74,7 +74,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `(function() {});`,
+      code: '(function() {});',
       options: [
         {
           allowExpressions: true,
@@ -83,7 +83,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `(() => {})();`,
+      code: '(() => {})();',
       options: [
         {
           allowExpressions: true,
@@ -92,7 +92,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `export default (): void => {}`,
+      code: 'export default (): void => {};',
       options: [
         {
           allowExpressions: true,
@@ -103,7 +103,7 @@ class Test {
       filename: 'test.ts',
       code: `
 var arrowFn: Foo = () => 'test';
-            `,
+      `,
       options: [
         {
           allowTypedFunctionExpressions: true,
@@ -113,8 +113,10 @@ var arrowFn: Foo = () => 'test';
     {
       filename: 'test.ts',
       code: `
-var funcExpr: Foo = function() { return 'test'; };
-            `,
+var funcExpr: Foo = function() {
+  return 'test';
+};
+      `,
       options: [
         {
           allowTypedFunctionExpressions: true,
@@ -123,12 +125,12 @@ var funcExpr: Foo = function() { return 'test'; };
     },
     {
       filename: 'test.ts',
-      code: `const x = (() => {}) as Foo`,
+      code: 'const x = (() => {}) as Foo;',
       options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       filename: 'test.ts',
-      code: `const x = <Foo>(() => {})`,
+      code: 'const x = <Foo>(() => {});',
       options: [{ allowTypedFunctionExpressions: true }],
     },
     {
@@ -136,7 +138,7 @@ var funcExpr: Foo = function() { return 'test'; };
       code: `
 const x = {
   foo: () => {},
-} as Foo
+} as Foo;
       `,
       options: [{ allowTypedFunctionExpressions: true }],
     },
@@ -145,7 +147,7 @@ const x = {
       code: `
 const x = <Foo>{
   foo: () => {},
-}
+};
       `,
       options: [{ allowTypedFunctionExpressions: true }],
     },
@@ -154,7 +156,7 @@ const x = <Foo>{
       code: `
 const x: Foo = {
   foo: () => {},
-}
+};
       `,
       options: [{ allowTypedFunctionExpressions: true }],
     },
@@ -165,7 +167,7 @@ const x: Foo = {
 type MethodType = () => void;
 
 class App {
-  private method: MethodType = () => {}
+  private method: MethodType = () => {};
 }
       `,
       options: [{ allowTypedFunctionExpressions: true }],
@@ -185,42 +187,50 @@ const myObj = {
       filename: 'test.ts',
       code: `
 () => (): void => {};
-            `,
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       filename: 'test.ts',
       code: `
-() => function (): void {};
-            `,
+() => function(): void {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       filename: 'test.ts',
       code: `
-() => { return (): void => {} };
-            `,
+() => {
+  return (): void => {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       filename: 'test.ts',
       code: `
-() => { return function (): void {} };
-            `,
+() => {
+  return function(): void {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       filename: 'test.ts',
       code: `
-function fn() { return (): void => {} };
-            `,
+function fn() {
+  return (): void => {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       filename: 'test.ts',
       code: `
-function fn() { return function (): void {} };
-            `,
+function fn() {
+  return function(): void {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -229,33 +239,39 @@ function fn() { return function (): void {} };
 function FunctionDeclaration() {
   return function FunctionExpression_Within_FunctionDeclaration() {
     return function FunctionExpression_Within_FunctionExpression() {
-      return () => { // ArrowFunctionExpression_Within_FunctionExpression
-        return () => // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          (): number => 1 // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
-      }
-    }
-  }
+      return () => {
+        // ArrowFunctionExpression_Within_FunctionExpression
+        return () =>
+          // ArrowFunctionExpression_Within_ArrowFunctionExpression
+          (): number => 1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
+      };
+    };
+  };
 }
-            `,
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       filename: 'test.ts',
       code: `
-() => () => { return (): void => { return; } };
-            `,
+() => () => {
+  return (): void => {
+    return;
+  };
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/679
     {
       filename: 'test.ts',
       code: `
-declare function foo(arg: () => void): void
-foo(() => 1)
-foo(() => {})
-foo(() => null)
-foo(() => true)
-foo(() => '')
+declare function foo(arg: () => void): void;
+foo(() => 1);
+foo(() => {});
+foo(() => null);
+foo(() => true);
+foo(() => '');
       `,
       options: [
         {
@@ -266,12 +282,12 @@ foo(() => '')
     {
       filename: 'test.ts',
       code: `
-declare function foo(arg: () => void): void
-foo?.(() => 1)
-foo?.bar(() => {})
-foo?.bar?.(() => null)
-foo.bar?.(() => true)
-foo?.(() => '')
+declare function foo(arg: () => void): void;
+foo?.(() => 1);
+foo?.bar(() => {});
+foo?.bar?.(() => null);
+foo.bar?.(() => true);
+foo?.(() => '');
       `,
       options: [
         {
@@ -301,22 +317,22 @@ new Accumulator().accumulate(() => 1);
     {
       filename: 'test.ts',
       code: `
-declare function foo(arg: { meth: () => number }): void
+declare function foo(arg: { meth: () => number }): void;
 foo({
   meth() {
     return 1;
   },
-})
+});
 foo({
-  meth: function () {
+  meth: function() {
     return 1;
   },
-})
+});
 foo({
   meth: () => {
     return 1;
   },
-})
+});
       `,
       options: [
         {
@@ -327,9 +343,9 @@ foo({
     {
       filename: 'test.ts',
       code: `
-const func = (value: number) => (({ type: "X", value }) as const);
-const func = (value: number) => ({ type: "X", value } as const);
-const func = (value: number) => (x as const);
+const func = (value: number) => ({ type: 'X', value } as const);
+const func = (value: number) => ({ type: 'X', value } as const);
+const func = (value: number) => x as const;
 const func = (value: number) => x as const;
       `,
       options: [
@@ -355,10 +371,7 @@ new Foo(1, () => {});
     {
       filename: 'test.ts',
       code: `
-function test(
-  a: number,
-  b: number,
-) {
+function test(a: number, b: number) {
   return;
 }
       `,
@@ -366,9 +379,9 @@ function test(
         {
           messageId: 'missingReturnType',
           line: 2,
-          endLine: 5,
+          endLine: 2,
           column: 1,
-          endColumn: 2,
+          endColumn: 36,
         },
       ],
     },
@@ -427,7 +440,7 @@ var arrowFn = () => 'test';
 class Test {
   constructor() {}
   get prop() {
-      return 1;
+    return 1;
   }
   set prop() {}
   method() {
@@ -532,7 +545,7 @@ function test() {
     },
     {
       filename: 'test.ts',
-      code: 'export default function() {};',
+      code: 'export default function() {}',
       options: [{ allowExpressions: true }],
       errors: [
         {
@@ -549,11 +562,11 @@ function test() {
       code: `
 class Foo {
   public a = () => {};
-  public b = function () {};
+  public b = function() {};
   public c = function test() {};
 
   static d = () => {};
-  static e = function () {};
+  static e = function() {};
 }
       `,
       options: [{ allowExpressions: true }],
@@ -570,7 +583,7 @@ class Foo {
           line: 4,
           endLine: 4,
           column: 14,
-          endColumn: 25,
+          endColumn: 24,
         },
         {
           messageId: 'missingReturnType',
@@ -591,7 +604,7 @@ class Foo {
           line: 8,
           endLine: 8,
           column: 14,
-          endColumn: 25,
+          endColumn: 24,
         },
       ],
     },
@@ -611,13 +624,17 @@ class Foo {
     },
     {
       filename: 'test.ts',
-      code: "var funcExpr = function() { return 'test'; };",
+      code: `
+var funcExpr = function() {
+  return 'test';
+};
+      `,
       options: [{ allowTypedFunctionExpressions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
+          line: 2,
+          endLine: 2,
           column: 16,
           endColumn: 26,
         },
@@ -626,7 +643,7 @@ class Foo {
 
     {
       filename: 'test.ts',
-      code: 'const x = (() => {}) as Foo',
+      code: 'const x = (() => {}) as Foo;',
       options: [{ allowTypedFunctionExpressions: false }],
       errors: [
         {
@@ -644,7 +661,7 @@ class Foo {
 interface Foo {}
 const x = {
   foo: () => {},
-} as Foo
+} as Foo;
       `,
       options: [{ allowTypedFunctionExpressions: false }],
       errors: [
@@ -663,7 +680,7 @@ const x = {
 interface Foo {}
 const x: Foo = {
   foo: () => {},
-}
+};
       `,
       options: [{ allowTypedFunctionExpressions: false }],
       errors: [
@@ -692,7 +709,7 @@ const x: Foo = {
     },
     {
       filename: 'test.ts',
-      code: '() => function () {};',
+      code: '() => function() {};',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
@@ -700,63 +717,79 @@ const x: Foo = {
           line: 1,
           endLine: 1,
           column: 7,
-          endColumn: 18,
+          endColumn: 17,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: '() => { return () => {} };',
+      code: `
+() => {
+  return () => {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 16,
-          endColumn: 21,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 15,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: '() => { return function () {} };',
+      code: `
+() => {
+  return function() {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 16,
-          endColumn: 27,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 20,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: 'function fn() { return () => {} };',
+      code: `
+function fn() {
+  return () => {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 24,
-          endColumn: 29,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 15,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: 'function fn() { return function () {} };',
+      code: `
+function fn() {
+  return function() {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 24,
-          endColumn: 35,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 20,
         },
       ],
     },
@@ -766,20 +799,22 @@ const x: Foo = {
 function FunctionDeclaration() {
   return function FunctionExpression_Within_FunctionDeclaration() {
     return function FunctionExpression_Within_FunctionExpression() {
-      return () => { // ArrowFunctionExpression_Within_FunctionExpression
-        return () => // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          () => 1 // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
-      }
-    }
-  }
+      return () => {
+        // ArrowFunctionExpression_Within_FunctionExpression
+        return () =>
+          // ArrowFunctionExpression_Within_ArrowFunctionExpression
+          () => 1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
+      };
+    };
+  };
 }
-            `,
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 7,
-          endLine: 7,
+          line: 9,
+          endLine: 9,
           column: 11,
           endColumn: 16,
         },
@@ -787,15 +822,21 @@ function FunctionDeclaration() {
     },
     {
       filename: 'test.ts',
-      code: '() => () => { return () => { return; } };',
+      code: `
+() => () => {
+  return () => {
+    return;
+  };
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 22,
-          endColumn: 27,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 15,
         },
       ],
     },
@@ -803,12 +844,12 @@ function FunctionDeclaration() {
     {
       filename: 'test.ts',
       code: `
-declare function foo(arg: () => void): void
-foo(() => 1)
-foo(() => {})
-foo(() => null)
-foo(() => true)
-foo(() => '')
+declare function foo(arg: () => void): void;
+foo(() => 1);
+foo(() => {});
+foo(() => null);
+foo(() => true);
+foo(() => '');
       `,
       options: [
         {
@@ -883,7 +924,7 @@ new Accumulator().accumulate(() => 1);
     },
     {
       filename: 'test.ts',
-      code: '(() => true)()',
+      code: '(() => true)();',
       options: [
         {
           allowTypedFunctionExpressions: false,
@@ -902,22 +943,22 @@ new Accumulator().accumulate(() => 1);
     {
       filename: 'test.ts',
       code: `
-declare function foo(arg: { meth: () => number }): void
+declare function foo(arg: { meth: () => number }): void;
 foo({
   meth() {
     return 1;
   },
-})
+});
 foo({
-  meth: function () {
+  meth: function() {
     return 1;
   },
-})
+});
 foo({
   meth: () => {
     return 1;
   },
-})
+});
       `,
       options: [
         {
@@ -937,7 +978,7 @@ foo({
           line: 9,
           endLine: 9,
           column: 9,
-          endColumn: 20,
+          endColumn: 19,
         },
         {
           messageId: 'missingReturnType',
@@ -951,8 +992,8 @@ foo({
     {
       filename: 'test.ts',
       code: `
-const func = (value: number) => ({ type: "X", value } as any);
-const func = (value: number) => ({ type: "X", value } as Action);
+const func = (value: number) => ({ type: 'X', value } as any);
+const func = (value: number) => ({ type: 'X', value } as Action);
       `,
       options: [
         {
@@ -979,7 +1020,7 @@ const func = (value: number) => ({ type: "X", value } as Action);
     {
       filename: 'test.ts',
       code: `
-const func = (value: number) => ({ type: "X", value } as const);
+const func = (value: number) => ({ type: 'X', value } as const);
       `,
       options: [
         {
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 fe0a09dd4c1..906f1b6cc60 100644
--- a/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
+++ b/packages/eslint-plugin/tests/rules/explicit-member-accessibility.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/explicit-member-accessibility';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -109,72 +109,72 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  protected name: string
-  private x: number
-  public getX () {
-    return this.x
+  protected name: string;
+  private x: number;
+  public getX() {
+    return this.x;
   }
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  protected name: string
-  protected foo?: string
-  public "foo-bar"?: string
+  protected name: string;
+  protected foo?: string;
+  public 'foo-bar'?: string;
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  public constructor({x, y}: {x: number; y: number;}) {}
+  public constructor({ x, y }: { x: number; y: number }) {}
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  protected name: string
-  protected foo?: string
-  public getX () {
-    return this.x
+  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
+  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
+  name: string;
+  foo?: string;
+  getX() {
+    return this.x;
   }
   get fooName(): string {
-    return this.foo + ' ' + this.name
+    return this.foo + ' ' + this.name;
   }
 }
-            `,
+      `,
       options: [{ accessibility: 'no-public' }],
     },
     {
@@ -182,7 +182,7 @@ class Test {
       code: `
 class Test {
   private x: number;
-  constructor (x: number) {
+  constructor(x: number) {
     this.x = x;
   }
   get internalValue() {
@@ -191,7 +191,7 @@ class Test {
   private set internalValue(value: number) {
     this.x = value;
   }
-  public square (): number {
+  public square(): number {
     return this.x * this.x;
   }
 }
@@ -203,7 +203,7 @@ class Test {
       code: `
 class Test {
   private x: number;
-  public constructor (x: number) {
+  public constructor(x: number) {
     this.x = x;
   }
   public get internalValue() {
@@ -212,10 +212,10 @@ class Test {
   public set internalValue(value: number) {
     this.x = value;
   }
-  public square (): number {
+  public square(): number {
     return this.x * this.x;
   }
-  half (): number {
+  half(): number {
     return this.x / 2;
   }
 }
@@ -226,7 +226,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  constructor(private x: number){}
+  constructor(private x: number) {}
 }
       `,
       options: [{ accessibility: 'no-public' }],
@@ -235,7 +235,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  constructor(public x: number){}
+  constructor(public x: number) {}
 }
       `,
       options: [
@@ -249,7 +249,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  constructor(public foo: number){}
+  constructor(public foo: number) {}
 }
       `,
       options: [{ accessibility: 'no-public' }],
@@ -258,8 +258,8 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  public getX () {
-    return this.x
+  public getX() {
+    return this.x;
   }
 }
       `,
@@ -269,8 +269,8 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  public static getX () {
-    return this.x
+  public static getX() {
+    return this.x;
   }
 }
       `,
@@ -280,8 +280,8 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  get getX () {
-    return this.x
+  get getX() {
+    return this.x;
   }
 }
       `,
@@ -291,8 +291,8 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  getX () {
-    return this.x
+  getX() {
+    return this.x;
   }
 }
       `,
@@ -300,24 +300,38 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: 'class Test { x = 2 }',
+      code: `
+class Test {
+  x = 2;
+}
+      `,
       options: [{ overrides: { properties: 'off' } }],
     },
     {
       filename: 'test.ts',
-      code: 'class Test { private x = 2 }',
+      code: `
+class Test {
+  private x = 2;
+}
+      `,
       options: [{ overrides: { properties: 'explicit' } }],
     },
     {
       filename: 'test.ts',
-      code: `class Test {
-        x = 2
-        private x = 2
-      }`,
+      code: `
+class Test {
+  x = 2;
+  private x = 2;
+}
+      `,
       options: [{ overrides: { properties: 'no-public' } }],
     },
     {
-      code: 'class Test { constructor(private { x }: any[]) { }}',
+      code: `
+class Test {
+  constructor(private { x }: any[]) {}
+}
+      `,
       options: [{ accessibility: 'no-public' }],
     },
   ],
@@ -412,12 +426,12 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  x: number
-  public getX () {
-    return this.x
+  x: number;
+  public getX() {
+    return this.x;
   }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'missingAccessibility',
@@ -431,23 +445,23 @@ class Test {
       ],
       output: `
 class Test {
-  x: number
-  public getX () {
-    return this.x
+  x: number;
+  public getX() {
+    return this.x;
   }
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  private x: number
-  getX () {
-    return this.x
+  private x: number;
+  getX() {
+    return this.x;
   }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'missingAccessibility',
@@ -461,23 +475,23 @@ class Test {
       ],
       output: `
 class Test {
-  private x: number
-  getX () {
-    return this.x
+  private x: number;
+  getX() {
+    return this.x;
   }
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  x?: number
-  getX? () {
-    return this.x
+  x?: number;
+  getX?() {
+    return this.x;
   }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'missingAccessibility',
@@ -500,24 +514,24 @@ class Test {
       ],
       output: `
 class Test {
-  x?: number
-  getX? () {
-    return this.x
+  x?: number;
+  getX?() {
+    return this.x;
   }
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  protected name: string
-  protected foo?: string
-  public getX () {
-    return this.x
+  protected name: string;
+  protected foo?: string;
+  public getX() {
+    return this.x;
   }
 }
-            `,
+      `,
       options: [{ accessibility: 'no-public' }],
       errors: [
         {
@@ -532,25 +546,25 @@ class Test {
       ],
       output: `
 class Test {
-  protected name: string
-  protected foo?: string
-  getX () {
-    return this.x
+  protected name: string;
+  protected foo?: string;
+  getX() {
+    return this.x;
   }
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  protected name: string
-  public foo?: string
-  getX () {
-    return this.x
+  protected name: string;
+  public foo?: string;
+  getX() {
+    return this.x;
   }
 }
-            `,
+      `,
       options: [{ accessibility: 'no-public' }],
       errors: [
         {
@@ -565,24 +579,24 @@ class Test {
       ],
       output: `
 class Test {
-  protected name: string
-  foo?: string
-  getX () {
-    return this.x
+  protected name: string;
+  foo?: string;
+  getX() {
+    return this.x;
   }
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
-  public x: number
-  public getX () {
-    return this.x
+  public x: number;
+  public getX() {
+    return this.x;
   }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unwantedPublicAccessibility',
@@ -598,19 +612,19 @@ class Test {
       options: [{ accessibility: 'no-public' }],
       output: `
 class Test {
-  x: number
-  getX () {
-    return this.x
+  x: number;
+  getX() {
+    return this.x;
   }
 }
-            `,
+      `,
     },
     {
       filename: 'test.ts',
       code: `
 class Test {
   private x: number;
-  constructor (x: number) {
+  constructor(x: number) {
     this.x = x;
   }
   get internalValue() {
@@ -637,7 +651,7 @@ class Test {
       output: `
 class Test {
   private x: number;
-  constructor (x: number) {
+  constructor(x: number) {
     this.x = x;
   }
   get internalValue() {
@@ -654,7 +668,7 @@ class Test {
       code: `
 class Test {
   private x: number;
-  constructor (x: number) {
+  constructor(x: number) {
     this.x = x;
   }
   get internalValue() {
@@ -685,7 +699,7 @@ class Test {
       output: `
 class Test {
   private x: number;
-  constructor (x: number) {
+  constructor(x: number) {
     this.x = x;
   }
   get internalValue() {
@@ -701,7 +715,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  constructor(public x: number){}
+  constructor(public x: number) {}
   public foo(): string {
     return 'foo';
   }
@@ -721,7 +735,7 @@ class Test {
       ],
       output: `
 class Test {
-  constructor(public x: number){}
+  constructor(public x: number) {}
   public foo(): string {
     return 'foo';
   }
@@ -732,7 +746,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  constructor(public x: number){}
+  constructor(public x: number) {}
 }
       `,
       errors: [
@@ -744,7 +758,7 @@ class Test {
       ],
       output: `
 class Test {
-  constructor(public x: number){}
+  constructor(public x: number) {}
 }
       `,
     },
@@ -752,7 +766,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  constructor(public readonly x: number){}
+  constructor(public readonly x: number) {}
 }
       `,
       options: [
@@ -770,13 +784,17 @@ class Test {
       ],
       output: `
 class Test {
-  constructor(readonly x: number){}
+  constructor(readonly x: number) {}
 }
       `,
     },
     {
       filename: 'test.ts',
-      code: 'class Test { x = 2 }',
+      code: `
+class Test {
+  x = 2;
+}
+      `,
       options: [
         {
           accessibility: 'off',
@@ -786,18 +804,24 @@ class Test {
       errors: [
         {
           messageId: 'missingAccessibility',
-          line: 1,
-          column: 14,
+          line: 3,
+          column: 3,
         },
       ],
-      output: 'class Test { x = 2 }',
+      output: `
+class Test {
+  x = 2;
+}
+      `,
     },
     {
       filename: 'test.ts',
-      code: `class Test {
-        public x = 2
-        private x = 2
-      }`,
+      code: `
+class Test {
+  public x = 2;
+  private x = 2;
+}
+      `,
       options: [
         {
           accessibility: 'off',
@@ -807,30 +831,40 @@ class Test {
       errors: [
         {
           messageId: 'unwantedPublicAccessibility',
-          line: 2,
-          column: 9,
+          line: 3,
+          column: 3,
         },
       ],
-      output: `class Test {
-        x = 2
-        private x = 2
-      }`,
+      output: `
+class Test {
+  x = 2;
+  private x = 2;
+}
+      `,
     },
     {
-      code: 'class Test { constructor(public ...x: any[]) { }}',
+      code: `
+class Test {
+  constructor(public ...x: any[]) {}
+}
+      `,
       options: [{ accessibility: 'explicit' }],
       errors: [
         {
           messageId: 'missingAccessibility',
-          line: 1,
-          column: 14,
+          line: 3,
+          column: 3,
         },
       ],
-      output: 'class Test { constructor(public ...x: any[]) { }}',
+      output: `
+class Test {
+  constructor(public ...x: any[]) {}
+}
+      `,
     },
     {
       filename: 'test.ts',
-      code: `
+      code: noFormat`
 class Test {
   @public
   public /*public*/constructor(private foo: string) {}
@@ -848,7 +882,7 @@ class Test {
           column: 3,
         },
       ],
-      output: `
+      output: noFormat`
 class Test {
   @public
   /*public*/constructor(private foo: string) {}
@@ -914,7 +948,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  public foo = "";
+  public foo = '';
 }
       `,
       options: [
@@ -931,16 +965,16 @@ class Test {
       ],
       output: `
 class Test {
-  foo = "";
+  foo = '';
 }
       `,
     },
 
     {
       filename: 'test.ts',
-      code: `
+      code: noFormat`
 class Test {
-  contructor(public/* Hi there */ readonly foo)
+  contructor(public/* Hi there */ readonly foo);
 }
       `,
       options: [
@@ -958,7 +992,7 @@ class Test {
       ],
       output: `
 class Test {
-  contructor(/* Hi there */ readonly foo)
+  contructor(/* Hi there */ readonly foo);
 }
       `,
     },
@@ -966,7 +1000,7 @@ class Test {
       filename: 'test.ts',
       code: `
 class Test {
-  contructor(public readonly foo: string)
+  contructor(public readonly foo: string);
 }
       `,
       options: [
@@ -983,33 +1017,17 @@ class Test {
       ],
       output: `
 class Test {
-  contructor(readonly foo: string)
+  contructor(readonly foo: string);
 }
       `,
     },
     {
       filename: 'test.ts',
-      code:
-        'class EnsureWhiteSPaceSpan { public              constructor() {}}',
-      options: [
-        {
-          accessibility: 'no-public',
-          overrides: { parameterProperties: 'no-public' },
-        },
-      ],
-      errors: [
-        {
-          messageId: 'unwantedPublicAccessibility',
-          line: 1,
-          column: 30,
-        },
-      ],
-      output: 'class EnsureWhiteSPaceSpan { constructor() {}}',
-    },
-    {
-      filename: 'test.ts',
-      code:
-        'class EnsureWhiteSPaceSpan { public /* */              constructor() {}}',
+      code: `
+class EnsureWhiteSPaceSpan {
+  public constructor() {}
+}
+      `,
       options: [
         {
           accessibility: 'no-public',
@@ -1019,17 +1037,23 @@ class Test {
       errors: [
         {
           messageId: 'unwantedPublicAccessibility',
-          line: 1,
-          column: 30,
+          line: 3,
+          column: 3,
         },
       ],
-      output:
-        'class EnsureWhiteSPaceSpan { /* */              constructor() {}}',
+      output: `
+class EnsureWhiteSPaceSpan {
+  constructor() {}
+}
+      `,
     },
     {
       filename: 'test.ts',
-      code:
-        'class EnsureWhiteSPaceSpan { public              /* */ constructor() {}}',
+      code: `
+class EnsureWhiteSPaceSpan {
+  public /* */ constructor() {}
+}
+      `,
       options: [
         {
           accessibility: 'no-public',
@@ -1039,11 +1063,15 @@ class Test {
       errors: [
         {
           messageId: 'unwantedPublicAccessibility',
-          line: 1,
-          column: 30,
+          line: 3,
+          column: 3,
         },
       ],
-      output: 'class EnsureWhiteSPaceSpan { /* */ constructor() {}}',
+      output: `
+class EnsureWhiteSPaceSpan {
+  /* */ constructor() {}
+}
+      `,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts b/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts
index 388adb99431..cdff53533b7 100644
--- a/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/explicit-module-boundary-types.test.ts
@@ -10,28 +10,28 @@ ruleTester.run('explicit-module-boundary-types', rule, {
     {
       code: `
 function test(): void {
-    return;
+  return;
 }
-            `,
+      `,
     },
     {
       code: `
 export function test(): void {
-    return;
+  return;
 }
-            `,
+      `,
     },
     {
       code: `
 export var fn = function(): number {
-    return 1;
+  return 1;
 };
-            `,
+      `,
     },
     {
       code: `
 export var arrowFn = (): string => 'test';
-            `,
+      `,
     },
     {
       code: `
@@ -46,7 +46,7 @@ class Test {
   }
   arrow = (): string => 'arrow';
 }
-            `,
+      `,
     },
     {
       code: `
@@ -61,42 +61,42 @@ export class Test {
   }
   arrow = (): string => 'arrow';
 }
-            `,
+      `,
     },
     {
       code: `
 export function test(): void {
-    nested();
-    return;
+  nested();
+  return;
 
-    function nested() {}
+  function nested() {}
 }
-            `,
+      `,
     },
     {
       code: `
 export function test(): string {
-    const nested = () => 'value';
-    return nested();
+  const nested = () => 'value';
+  return nested();
 }
-            `,
+      `,
     },
     {
       code: `
 export function test(): string {
-    class Nested {
-        public method() {
-            return 'value';
-        }
+  class Nested {
+    public method() {
+      return 'value';
     }
-    return new Nested().method();
+  }
+  return new Nested().method();
 }
-            `,
+      `,
     },
     {
       code: `
 export var arrowFn: Foo = () => 'test';
-            `,
+      `,
       options: [
         {
           allowTypedFunctionExpressions: true,
@@ -105,8 +105,10 @@ export var arrowFn: Foo = () => 'test';
     },
     {
       code: `
-export var funcExpr: Foo = function() { return 'test'; };
-            `,
+export var funcExpr: Foo = function() {
+  return 'test';
+};
+      `,
       options: [
         {
           allowTypedFunctionExpressions: true,
@@ -114,18 +116,18 @@ export var funcExpr: Foo = function() { return 'test'; };
       ],
     },
     {
-      code: `const x = (() => {}) as Foo`,
+      code: 'const x = (() => {}) as Foo;',
       options: [{ allowTypedFunctionExpressions: true }],
     },
     {
-      code: `const x = <Foo>(() => {})`,
+      code: 'const x = <Foo>(() => {});',
       options: [{ allowTypedFunctionExpressions: true }],
     },
     {
       code: `
 export const x = {
   foo: () => {},
-} as Foo
+} as Foo;
       `,
       options: [{ allowTypedFunctionExpressions: true }],
     },
@@ -133,7 +135,7 @@ export const x = {
       code: `
 export const x = <Foo>{
   foo: () => {},
-}
+};
       `,
       options: [{ allowTypedFunctionExpressions: true }],
     },
@@ -141,7 +143,7 @@ export const x = <Foo>{
       code: `
 export const x: Foo = {
   foo: () => {},
-}
+};
       `,
       options: [{ allowTypedFunctionExpressions: true }],
     },
@@ -151,7 +153,7 @@ export const x: Foo = {
 type MethodType = () => void;
 
 export class App {
-  public method: MethodType = () => {}
+  public method: MethodType = () => {};
 }
       `,
       options: [{ allowTypedFunctionExpressions: true }],
@@ -169,37 +171,45 @@ export const myObj = {
     {
       code: `
 export default () => (): void => {};
-            `,
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export default () => function (): void {};
-            `,
+export default () => function(): void {};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export default () => { return (): void => {} };
-            `,
+export default () => {
+  return (): void => {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export default () => { return function (): void {} };
-            `,
+export default () => {
+  return function(): void {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function fn() { return (): void => {} };
-            `,
+export function fn() {
+  return (): void => {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export function fn() { return function (): void {} };
-            `,
+export function fn() {
+  return function(): void {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -207,20 +217,26 @@ export function fn() { return function (): void {} };
 export function FunctionDeclaration() {
   return function FunctionExpression_Within_FunctionDeclaration() {
     return function FunctionExpression_Within_FunctionExpression() {
-      return () => { // ArrowFunctionExpression_Within_FunctionExpression
-        return () => // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          (): number => 1 // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
-      }
-    }
-  }
+      return () => {
+        // ArrowFunctionExpression_Within_FunctionExpression
+        return () =>
+          // ArrowFunctionExpression_Within_ArrowFunctionExpression
+          (): number => 1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
+      };
+    };
+  };
 }
-            `,
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
       code: `
-export default () => () => { return (): void => { return; } };
-            `,
+export default () => () => {
+  return (): void => {
+    return;
+  };
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
     },
     {
@@ -243,9 +259,9 @@ new Accumulator().accumulate(() => 1);
     },
     {
       code: `
-export const func1 = (value: number) => (({ type: "X", value }) as const);
-export const func2 = (value: number) => ({ type: "X", value } as const);
-export const func3 = (value: number) => (x as const);
+export const func1 = (value: number) => ({ type: 'X', value } as const);
+export const func2 = (value: number) => ({ type: 'X', value } as const);
+export const func3 = (value: number) => x as const;
 export const func4 = (value: number) => x as const;
       `,
       options: [
@@ -257,7 +273,7 @@ export const func4 = (value: number) => x as const;
     {
       code: `
 export const func1 = (value: string) => value;
-export const func2 = (value: number) => ({ type: "X", value });
+export const func2 = (value: number) => ({ type: 'X', value });
       `,
       options: [
         {
@@ -315,13 +331,8 @@ export class Test {
     {
       code: `
 export const Foo: FC = () => (
-  <div
-    a={e => {}}
-    b={function (e) {}}
-    c={function foo(e) {}}
-  >
-  </div>
-)
+  <div a={e => {}} b={function(e) {}} c={function foo(e) {}}></div>
+);
       `,
       parserOptions: {
         ecmaFeatures: { jsx: true },
@@ -329,13 +340,9 @@ export const Foo: FC = () => (
     },
     {
       code: `
-export const Foo: JSX.Element =
-  <div
-    a={e => {}}
-    b={function (e) {}}
-    c={function foo(e) {}}
-  >
-  </div>
+export const Foo: JSX.Element = (
+  <div a={e => {}} b={function(e) {}} c={function foo(e) {}}></div>
+);
       `,
       parserOptions: {
         ecmaFeatures: { jsx: true },
@@ -345,10 +352,7 @@ export const Foo: JSX.Element =
   invalid: [
     {
       code: `
-export function test(
-  a: number,
-  b: number,
-) {
+export function test(a: number, b: number) {
   return;
 }
       `,
@@ -356,9 +360,9 @@ export function test(
         {
           messageId: 'missingReturnType',
           line: 2,
-          endLine: 5,
+          endLine: 2,
           column: 8,
-          endColumn: 2,
+          endColumn: 43,
         },
       ],
     },
@@ -413,13 +417,13 @@ export var arrowFn = () => 'test';
 export class Test {
   constructor() {}
   get prop() {
-      return 1;
+    return 1;
   }
   set prop(value) {}
   method() {
     return;
   }
-  arrow = (arg) => 'arrow';
+  arrow = arg => 'arrow';
   private method() {
     return;
   }
@@ -452,14 +456,14 @@ export class Test {
           line: 11,
           endLine: 11,
           column: 11,
-          endColumn: 19,
+          endColumn: 17,
         },
         {
           messageId: 'missingArgType',
           line: 11,
           endLine: 11,
           column: 11,
-          endColumn: 27,
+          endColumn: 25,
         },
       ],
     },
@@ -467,11 +471,11 @@ export class Test {
       code: `
 export class Foo {
   public a = () => {};
-  public b = function () {};
+  public b = function() {};
   public c = function test() {};
 
   static d = () => {};
-  static e = function () {};
+  static e = function() {};
 }
       `,
       errors: [
@@ -487,7 +491,7 @@ export class Foo {
           line: 4,
           endLine: 4,
           column: 14,
-          endColumn: 25,
+          endColumn: 24,
         },
         {
           messageId: 'missingReturnType',
@@ -508,12 +512,12 @@ export class Foo {
           line: 8,
           endLine: 8,
           column: 14,
-          endColumn: 25,
+          endColumn: 24,
         },
       ],
     },
     {
-      code: 'export default () => true ? (() => {}) : ((): void => {});',
+      code: 'export default () => (true ? () => {} : (): void => {});',
       errors: [
         {
           messageId: 'missingReturnType',
@@ -545,20 +549,24 @@ export class Foo {
       ],
     },
     {
-      code: "export var funcExpr = function() { return 'test'; };",
+      code: `
+export var funcExpr = function() {
+  return 'test';
+};
+      `,
       options: [{ allowTypedFunctionExpressions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
+          line: 2,
+          endLine: 2,
           column: 23,
           endColumn: 33,
         },
       ],
     },
     {
-      code: 'export const x = (() => {}) as Foo',
+      code: 'export const x = (() => {}) as Foo;',
       options: [{ allowTypedFunctionExpressions: false }],
       errors: [
         {
@@ -575,7 +583,7 @@ export class Foo {
 interface Foo {}
 export const x = {
   foo: () => {},
-} as Foo
+} as Foo;
       `,
       options: [{ allowTypedFunctionExpressions: false }],
       errors: [
@@ -593,7 +601,7 @@ export const x = {
 interface Foo {}
 export const x: Foo = {
   foo: () => {},
-}
+};
       `,
       options: [{ allowTypedFunctionExpressions: false }],
       errors: [
@@ -620,7 +628,7 @@ export const x: Foo = {
       ],
     },
     {
-      code: 'export default () => function () {};',
+      code: 'export default () => function() {};',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
@@ -628,59 +636,75 @@ export const x: Foo = {
           line: 1,
           endLine: 1,
           column: 22,
-          endColumn: 33,
+          endColumn: 32,
         },
       ],
     },
     {
-      code: 'export default () => { return () => {} };',
+      code: `
+export default () => {
+  return () => {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 31,
-          endColumn: 36,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 15,
         },
       ],
     },
     {
-      code: 'export default () => { return function () {} };',
+      code: `
+export default () => {
+  return function() {};
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 31,
-          endColumn: 42,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 20,
         },
       ],
     },
     {
-      code: 'export function fn() { return () => {} };',
+      code: `
+export function fn() {
+  return () => {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 31,
-          endColumn: 36,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 15,
         },
       ],
     },
     {
-      code: 'export function fn() { return function () {} };',
+      code: `
+export function fn() {
+  return function() {};
+}
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 31,
-          endColumn: 42,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 20,
         },
       ],
     },
@@ -689,40 +713,48 @@ export const x: Foo = {
 export function FunctionDeclaration() {
   return function FunctionExpression_Within_FunctionDeclaration() {
     return function FunctionExpression_Within_FunctionExpression() {
-      return () => { // ArrowFunctionExpression_Within_FunctionExpression
-        return () => // ArrowFunctionExpression_Within_ArrowFunctionExpression
-          () => 1 // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
-      }
-    }
-  }
+      return () => {
+        // ArrowFunctionExpression_Within_FunctionExpression
+        return () =>
+          // ArrowFunctionExpression_Within_ArrowFunctionExpression
+          () => 1; // ArrowFunctionExpression_Within_ArrowFunctionExpression_WithNoBody
+      };
+    };
+  };
 }
-            `,
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 7,
-          endLine: 7,
+          line: 9,
+          endLine: 9,
           column: 11,
           endColumn: 16,
         },
       ],
     },
     {
-      code: 'export default () => () => { return () => { return; } };',
+      code: `
+export default () => () => {
+  return () => {
+    return;
+  };
+};
+      `,
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
-          endLine: 1,
-          column: 37,
-          endColumn: 42,
+          line: 3,
+          endLine: 3,
+          column: 10,
+          endColumn: 15,
         },
       ],
     },
     {
-      code: 'export default (() => true)()',
+      code: 'export default (() => true)();',
       options: [
         {
           allowTypedFunctionExpressions: false,
@@ -740,8 +772,8 @@ export function FunctionDeclaration() {
     },
     {
       code: `
-export const func1 = (value: number) => ({ type: "X", value } as any);
-export const func2 = (value: number) => ({ type: "X", value } as Action);
+export const func1 = (value: number) => ({ type: 'X', value } as any);
+export const func2 = (value: number) => ({ type: 'X', value } as Action);
       `,
       options: [
         {
@@ -767,7 +799,7 @@ export const func2 = (value: number) => ({ type: "X", value } as Action);
     },
     {
       code: `
-export const func = (value: number) => ({ type: "X", value } as const);
+export const func = (value: number) => ({ type: 'X', value } as const);
       `,
       options: [
         {
@@ -834,19 +866,23 @@ export const func2 = (value: number) => value;
       ],
     },
     {
-      code: 'export function fn(test): string { return "123" };',
+      code: `
+export function fn(test): string {
+  return '123';
+}
+      `,
       errors: [
         {
           messageId: 'missingArgType',
-          line: 1,
-          endLine: 1,
+          line: 2,
+          endLine: 4,
           column: 8,
-          endColumn: 50,
+          endColumn: 2,
         },
       ],
     },
     {
-      code: 'export const fn = (one: number, two): string => "123";',
+      code: "export const fn = (one: number, two): string => '123';",
       errors: [
         {
           messageId: 'missingArgType',
diff --git a/packages/eslint-plugin/tests/rules/func-call-spacing.test.ts b/packages/eslint-plugin/tests/rules/func-call-spacing.test.ts
index e2250716a07..db884fd3cf1 100644
--- a/packages/eslint-plugin/tests/rules/func-call-spacing.test.ts
+++ b/packages/eslint-plugin/tests/rules/func-call-spacing.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the spacing, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import { TSESLint } from '@typescript-eslint/experimental-utils';
 import rule, { MessageIds, Options } from '../../src/rules/func-call-spacing';
 import { RuleTester } from '../RuleTester';
@@ -180,7 +185,7 @@ ruleTester.run('func-call-spacing', rule, {
 this.cancelled.add(request)
 this.decrement(request)
 (request.reject(new api.Cancel()))
-      `,
+        `,
         output: null, // no change
         errors: [
           {
@@ -208,7 +213,7 @@ var a = foo
         code: `
 var a = foo
 (baz())
-      `,
+        `,
         output: null, // no change
         errors: [
           {
diff --git a/packages/eslint-plugin/tests/rules/generic-type-naming.test.ts b/packages/eslint-plugin/tests/rules/generic-type-naming.test.ts
index 11f7d1618bb..da26e9675b6 100644
--- a/packages/eslint-plugin/tests/rules/generic-type-naming.test.ts
+++ b/packages/eslint-plugin/tests/rules/generic-type-naming.test.ts
@@ -7,35 +7,60 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('generic-type-naming', rule, {
   valid: [
-    { code: 'class<T1,T2,T3> { }', options: [] },
-    { code: 'type ReadOnly<T extends object> = {}', options: [] },
-    { code: 'interface SimpleMap<TFoo> { }', options: [] },
-    { code: 'function get<T>() {}', options: [] },
-    { code: 'interface GenericIdentityFn { <T>(arg: T): T }', options: [] },
-    { code: 'class<x> { }', options: ['^x+$'] },
-    { code: 'class<A> { }', options: ['^[A-Z]$'] },
-    {
-      code: 'class<A> extends B<Test> implements Foo<Test> { }',
+    {
+      code: 'class<T1, T2, T3> {}',
+      options: [],
+    },
+    {
+      code: 'type ReadOnly<T extends object> = {};',
+      options: [],
+    },
+    {
+      code: 'interface SimpleMap<TFoo> {}',
+      options: [],
+    },
+    {
+      code: 'function get<T>() {}',
+      options: [],
+    },
+    {
+      code: `
+interface GenericIdentityFn {
+  <T>(arg: T): T;
+}
+      `,
+      options: [],
+    },
+    {
+      code: 'class<x> {}',
+      options: ['^x+$'],
+    },
+    {
+      code: 'class<A> {}',
+      options: ['^[A-Z]$'],
+    },
+    {
+      code: 'class<A> extends B<Test> implements Foo<Test> {}',
       options: ['^[A-Z]$'],
     },
     {
       code: `
 class<A> extends B<Test> implements Foo<Test> {
-    test<Z> () {
-        type Foo = Bar<Test>
-    }
+  test<Z>() {
+    type Foo = Bar<Test>;
+  }
 }
-            `,
+      `,
       options: ['^[A-Z]$'],
     },
     {
-      code: 'class CounterContainer extends Container<Counter> { }',
+      code: 'class CounterContainer extends Container<Counter> {}',
       options: ['^T$'],
     },
   ],
   invalid: [
     {
-      code: 'class<T,U,V> { }',
+      code: 'class<T, U, V> {}',
       options: [],
       errors: [
         {
@@ -49,7 +74,7 @@ class<A> extends B<Test> implements Foo<Test> {
       ],
     },
     {
-      code: 'class<x> { }',
+      code: 'class<x> {}',
       options: ['^[A-Z]+$'],
       errors: [
         {
@@ -61,7 +86,7 @@ class<A> extends B<Test> implements Foo<Test> {
       ],
     },
     {
-      code: 'interface SimpleMap<x> { }',
+      code: 'interface SimpleMap<x> {}',
       options: ['^[A-Z]+$'],
       errors: [
         {
@@ -73,7 +98,7 @@ class<A> extends B<Test> implements Foo<Test> {
       ],
     },
     {
-      code: 'type R<x> = {}',
+      code: 'type R<x> = {};',
       options: ['^[A-Z]+$'],
       errors: [
         {
@@ -97,25 +122,29 @@ class<A> extends B<Test> implements Foo<Test> {
       ],
     },
     {
-      code: 'interface GenericIdentityFn { <x>(arg: x): x }',
+      code: `
+interface GenericIdentityFn {
+  <x>(arg: x): x;
+}
+      `,
       options: ['^[A-Z]+$'],
       errors: [
         {
           messageId: 'paramNotMatchRule',
           data: { name: 'x', rule: '^[A-Z]+$' },
-          line: 1,
-          column: 32,
+          line: 3,
+          column: 4,
         },
       ],
     },
     {
       code: `
 class<A> extends B<Test> implements Foo<Test> {
-    test<Z> () {
-        type Foo<T> = Bar<Test>
-    }
+  test<Z>() {
+    type Foo<T> = Bar<Test>;
+  }
 }
-            `,
+      `,
       options: ['^[A-Z][0-9]$'],
       errors: [
         {
@@ -128,24 +157,24 @@ class<A> extends B<Test> implements Foo<Test> {
           messageId: 'paramNotMatchRule',
           data: { name: 'Z', rule: '^[A-Z][0-9]$' },
           line: 3,
-          column: 10,
+          column: 8,
         },
         {
           messageId: 'paramNotMatchRule',
           data: { name: 'T', rule: '^[A-Z][0-9]$' },
           line: 4,
-          column: 18,
+          column: 14,
         },
       ],
     },
     {
       code: `
 abstract class<A, B> extends B<Test> implements Foo<Test> {
-    test<Z> () {
-        type Foo<T> = Bar<Test>
-    }
+  test<Z>() {
+    type Foo<T> = Bar<Test>;
+  }
 }
-            `,
+      `,
       options: ['^[A-Z][0-9]$'],
       errors: [
         {
@@ -164,13 +193,13 @@ abstract class<A, B> extends B<Test> implements Foo<Test> {
           messageId: 'paramNotMatchRule',
           data: { name: 'Z', rule: '^[A-Z][0-9]$' },
           line: 3,
-          column: 10,
+          column: 8,
         },
         {
           messageId: 'paramNotMatchRule',
           data: { name: 'T', rule: '^[A-Z][0-9]$' },
           line: 4,
-          column: 18,
+          column: 14,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/indent/indent-eslint.test.ts b/packages/eslint-plugin/tests/rules/indent/indent-eslint.test.ts
index d726a5e2c95..a9dfda6b127 100644
--- a/packages/eslint-plugin/tests/rules/indent/indent-eslint.test.ts
+++ b/packages/eslint-plugin/tests/rules/indent/indent-eslint.test.ts
@@ -4,6 +4,11 @@
 // NOTE - this test suite is intentionally kept in a separate file to our
 // custom tests. This is to keep a clear boundary between the two.
 
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the spacing, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import {
   AST_TOKEN_TYPES,
   AST_NODE_TYPES,
diff --git a/packages/eslint-plugin/tests/rules/indent/indent.test.ts b/packages/eslint-plugin/tests/rules/indent/indent.test.ts
index fe88d3de17a..6cec699c053 100644
--- a/packages/eslint-plugin/tests/rules/indent/indent.test.ts
+++ b/packages/eslint-plugin/tests/rules/indent/indent.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the spacing, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import {
   AST_NODE_TYPES,
   TSESLint,
@@ -704,7 +709,7 @@ export default class App extends Vue
         return this.$store.state.errorHandler.error
     }
 }
-        `,
+    `,
     // https://github.com/eslint/typescript-eslint-parser/issues/474
     `
 /**
@@ -713,7 +718,7 @@ export default class App extends Vue
  * @returns {string}
  */
 function foo(name: string, age: number): string {}
-        `,
+    `,
     `
 const firebaseApp = firebase.apps.length
     ? firebase.app()
@@ -725,7 +730,7 @@ const firebaseApp = firebase.apps.length
         storageBucket: __FIREBASE_STORAGE_BUCKET__,
         messagingSenderId: __FIREBASE_MESSAGING_SENDER_ID__,
     })
-        `,
+    `,
     // https://github.com/bradzacher/eslint-plugin-typescript/issues/271
     {
       code: `
@@ -734,7 +739,7 @@ const foo = {
                 b: 2
             },
             bar = 1;
-            `,
+      `,
       options: [4, { VariableDeclarator: { const: 3 } }],
     },
     {
@@ -744,7 +749,7 @@ const foo : Foo = {
                 b: 2
             },
             bar = 1;
-            `,
+      `,
       options: [4, { VariableDeclarator: { const: 3 } }],
     },
     {
@@ -756,7 +761,7 @@ const name: string = '  Typescript  '
       greeting: string = (" Hello " + name)
         .toUpperCase()
         .trim();
-            `,
+      `,
       options: [2, { VariableDeclarator: { const: 3 } }],
     },
     {
@@ -768,15 +773,15 @@ const div: JQuery<HTMLElement> = $('<div>')
       button: JQuery<HTMLElement> = $('<button>')
         .text('Cancel')
         .appendTo(div);
-            `,
+      `,
       options: [2, { VariableDeclarator: { const: 3 } }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/441
-    `const;`,
+    'const;',
 
     // https://github.com/typescript-eslint/typescript-eslint/issues/1115
     {
-      code: `const foo = function<> (): void {}`,
+      code: 'const foo = function<> (): void {}',
     },
   ],
   invalid: [
@@ -787,13 +792,13 @@ type Foo = {
 bar : string,
 age : number,
 }
-            `,
+      `,
       output: `
 type Foo = {
     bar : string,
     age : number,
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -829,7 +834,7 @@ new(
 asdf: string,
 ): Foo,
 }
-            `,
+      `,
       output: `
 interface Foo {
     bar : string,
@@ -843,7 +848,7 @@ interface Foo {
         asdf: string,
     ): Foo,
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -945,7 +950,7 @@ baz : string,
 },
 age : number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     bar : {
@@ -953,7 +958,7 @@ interface Foo {
     },
     age : number,
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -999,13 +1004,13 @@ interface Foo extends Bar {
 bar : string,
 age : number,
 }
-            `,
+      `,
       output: `
 interface Foo extends Bar {
     bar : string,
     age : number,
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1036,14 +1041,14 @@ extends Bar {
 bar : string = "asdf";
 age : number = 1;
 }
-            `,
+      `,
       output: `
 class Foo
     extends Bar {
     bar : string = "asdf";
     age : number = 1;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1081,14 +1086,14 @@ extends Bar {
 bar : string,
 age : number,
 }
-            `,
+      `,
       output: `
 interface Foo
     extends Bar {
     bar : string,
     age : number,
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1125,13 +1130,13 @@ const foo : Foo<{
 bar : string,
 age : number,
 }>
-            `,
+      `,
       output: `
 const foo : Foo<{
     bar : string,
     age : number,
 }>
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1162,7 +1167,7 @@ age : number,
 bar : string,
 age : number,
 }
-            `,
+      `,
       output: `
 type T = {
     bar : string,
@@ -1171,7 +1176,7 @@ type T = {
     bar : string,
     age : number,
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1222,7 +1227,7 @@ age : number,
     bar : string,
     age : number,
 }
-            `,
+      `,
       output: `
 type T =
     | {
@@ -1233,7 +1238,7 @@ type T =
         bar : string,
         age : number,
     }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1292,12 +1297,13 @@ type T =
       ],
     },
     {
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
       code: `
     import Dialogs = require("widgets/Dialogs");
-            `,
+      `,
       output: `
 import Dialogs = require("widgets/Dialogs");
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1326,7 +1332,7 @@ asdf : number,
 private test : boolean,
 ) {}
 }
-            `,
+      `,
       output: `
 class Foo {
     public bar : string;
@@ -1342,7 +1348,7 @@ class Foo {
         private test : boolean,
     ) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1455,14 +1461,15 @@ class Foo {
       ],
     },
     {
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
       code: `
     abstract class Foo {}
     class Foo {}
-            `,
+      `,
       output: `
 abstract class Foo {}
 class Foo {}
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1491,14 +1498,14 @@ bar,
 baz = 1,
 buzz = '',
 }
-            `,
+      `,
       output: `
 enum Foo {
     bar,
     baz = 1,
     buzz = '',
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1536,14 +1543,14 @@ bar,
 baz = 1,
 buzz = '',
 }
-            `,
+      `,
       output: `
 const enum Foo {
     bar,
     baz = 1,
     buzz = '',
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1575,12 +1582,13 @@ const enum Foo {
       ],
     },
     {
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
       code: `
     export = Foo;
-            `,
+      `,
       output: `
 export = Foo;
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1594,12 +1602,13 @@ export = Foo;
       ],
     },
     {
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
       code: `
     declare function h(x: number): number;
-            `,
+      `,
       output: `
 declare function h(x: number): number;
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1617,12 +1626,12 @@ declare function h(x: number): number;
 declare function h(
 x: number,
 ): number;
-            `,
+      `,
       output: `
 declare function h(
     x: number,
 ): number;
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1642,14 +1651,14 @@ export interface StringValidator {
 isAcceptable(s: string): boolean;
 }
 }
-            `,
+      `,
       output: `
 namespace Validation {
     export interface StringValidator {
         isAcceptable(s: string): boolean;
     }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1687,14 +1696,14 @@ export interface StringValidator {
 isAcceptable(s: string): boolean;
 }
 }
-            `,
+      `,
       output: `
 declare module "Validation" {
     export interface StringValidator {
         isAcceptable(s: string): boolean;
     }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
@@ -1726,14 +1735,15 @@ declare module "Validation" {
       ],
     },
     {
+      // eslint-disable-next-line @typescript-eslint/internal/plugin-test-formatting
       code: `
     @Decorator()
 class Foo {}
-            `,
+      `,
       output: `
 @Decorator()
 class Foo {}
-            `,
+      `,
       errors: [
         {
           messageId: 'wrongIndentation',
diff --git a/packages/eslint-plugin/tests/rules/interface-name-prefix.test.ts b/packages/eslint-plugin/tests/rules/interface-name-prefix.test.ts
index 79e70f50ab8..23c58a4687a 100644
--- a/packages/eslint-plugin/tests/rules/interface-name-prefix.test.ts
+++ b/packages/eslint-plugin/tests/rules/interface-name-prefix.test.ts
@@ -30,55 +30,55 @@ ruleTester.run('interface-name-prefix', rule, {
   valid: [
     `
 interface Animal {
-    name: string;
+  name: string;
 }
-        `,
+    `,
     {
       code: `
 interface IAnimal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['always'],
     },
     {
       code: `
 interface _IAnimal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: [{ prefixWithI: 'always', allowUnderscorePrefix: true }],
     },
     {
       code: `
 interface IIguana {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['always'],
     },
     {
       code: `
 interface Iguana {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['never'],
     },
     {
       code: `
 interface Animal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['never'],
     },
     {
       code: `
 interface I18n {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['never'],
     },
   ],
@@ -86,9 +86,9 @@ interface I18n {
     {
       code: `
 interface IAnimal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noPrefix',
@@ -100,9 +100,9 @@ interface IAnimal {
     {
       code: `
 interface Animal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['always'],
       errors: [
         {
@@ -115,9 +115,9 @@ interface Animal {
     {
       code: `
 interface Animal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: [{ prefixWithI: 'always', allowUnderscorePrefix: true }],
       errors: [
         {
@@ -130,9 +130,9 @@ interface Animal {
     {
       code: `
 interface Iguana {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['always'],
       errors: [
         {
@@ -145,9 +145,9 @@ interface Iguana {
     {
       code: `
 interface IIguana {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['never'],
       errors: [
         {
@@ -160,9 +160,9 @@ interface IIguana {
     {
       code: `
 interface IAnimal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['never'],
       errors: [
         {
@@ -175,9 +175,9 @@ interface IAnimal {
     {
       code: `
 interface _IAnimal {
-    name: string;
+  name: string;
 }
-            `,
+      `,
       options: ['never'],
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/member-delimiter-style.test.ts b/packages/eslint-plugin/tests/rules/member-delimiter-style.test.ts
index 529f8a7c0bd..0ace2662313 100644
--- a/packages/eslint-plugin/tests/rules/member-delimiter-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-delimiter-style.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the delimiter, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import rule from '../../src/rules/member-delimiter-style';
 import { RuleTester } from '../RuleTester';
 
@@ -12,14 +17,14 @@ interface Foo {
     name: string;
     age: number;
 }
-        `,
+    `,
     {
       code: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -32,7 +37,7 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -45,7 +50,7 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -58,7 +63,7 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: true },
@@ -71,7 +76,7 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma' },
@@ -84,7 +89,7 @@ interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: false },
@@ -97,7 +102,7 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'none', requireLast: true },
@@ -110,7 +115,7 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'none', requireLast: false },
@@ -123,7 +128,7 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -147,7 +152,7 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -165,7 +170,7 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -189,7 +194,7 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -213,7 +218,7 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -231,7 +236,7 @@ interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -255,7 +260,7 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -276,7 +281,7 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -299,14 +304,14 @@ type Foo = {
     name: string;
     age: number;
 }
-        `,
+    `,
     {
       code: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: true } }],
     },
     {
@@ -315,7 +320,7 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi' } }],
     },
     {
@@ -324,7 +329,7 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: false } }],
     },
     {
@@ -333,7 +338,7 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: true } }],
     },
     {
@@ -342,7 +347,7 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma' } }],
     },
     {
@@ -351,7 +356,7 @@ type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: false } }],
     },
     {
@@ -360,7 +365,7 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: true } }],
     },
     {
@@ -369,7 +374,7 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
     },
     {
@@ -378,7 +383,7 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -399,7 +404,7 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -417,7 +422,7 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -441,7 +446,7 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -465,7 +470,7 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -483,7 +488,7 @@ type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -507,7 +512,7 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -528,7 +533,7 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -557,7 +562,7 @@ type Bar = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -709,7 +714,7 @@ interface Foo {
 }
 
 interface Bar { name: string, age: number }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -728,7 +733,7 @@ interface Foo {
 }
 
 type Bar = { name: string, age: number }
-            `,
+      `,
       options: [
         {
           multiline: {
@@ -755,13 +760,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSemi',
@@ -781,13 +786,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi' } }],
       errors: [
         {
@@ -808,13 +813,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: true } }],
       errors: [
         {
@@ -835,13 +840,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: false } }],
       errors: [
         {
@@ -857,13 +862,13 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: true } }],
       errors: [
         {
@@ -879,13 +884,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma' } }],
       errors: [
         {
@@ -906,13 +911,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: true } }],
       errors: [
         {
@@ -933,13 +938,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: false } }],
       errors: [
         {
@@ -955,13 +960,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma' } }],
       errors: [
         {
@@ -982,13 +987,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: true } }],
       errors: [
         {
@@ -1009,13 +1014,13 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: false } }],
       errors: [
         {
@@ -1031,13 +1036,13 @@ interface Foo {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: false } }],
       errors: [
         {
@@ -1058,13 +1063,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none' } }],
       errors: [
         {
@@ -1085,13 +1090,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: true } }],
       errors: [
         {
@@ -1112,13 +1117,13 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -1134,13 +1139,13 @@ interface Foo {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -1156,13 +1161,13 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none' } }],
       errors: [
         {
@@ -1183,13 +1188,13 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: true } }],
       errors: [
         {
@@ -1210,13 +1215,13 @@ interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -1232,13 +1237,13 @@ interface Foo {
     name: string
     age: number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -1254,13 +1259,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma' },
@@ -1288,13 +1293,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: false },
@@ -1324,13 +1329,13 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: false },
@@ -1355,13 +1360,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -1389,13 +1394,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -1428,13 +1433,13 @@ interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -1462,13 +1467,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -1496,13 +1501,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -1535,13 +1540,13 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -1569,13 +1574,13 @@ interface Foo {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -1608,13 +1613,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -1642,13 +1647,13 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -1678,13 +1683,13 @@ interface Foo {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -1712,13 +1717,13 @@ interface Foo {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -1746,13 +1751,13 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -1780,13 +1785,13 @@ interface Foo {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -1816,13 +1821,13 @@ interface Foo {
     name: string,
     age: number
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -1850,13 +1855,13 @@ interface Foo {
     name: string
     age: number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -1884,13 +1889,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSemi',
@@ -1910,13 +1915,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi' } }],
       errors: [
         {
@@ -1937,13 +1942,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: true } }],
       errors: [
         {
@@ -1964,13 +1969,13 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: true } }],
       errors: [
         {
@@ -1986,13 +1991,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma' } }],
       errors: [
         {
@@ -2013,13 +2018,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: true } }],
       errors: [
         {
@@ -2040,13 +2045,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: false } }],
       errors: [
         {
@@ -2062,13 +2067,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma' } }],
       errors: [
         {
@@ -2089,13 +2094,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: true } }],
       errors: [
         {
@@ -2116,13 +2121,13 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: false } }],
       errors: [
         {
@@ -2138,13 +2143,13 @@ type Foo = {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'comma', requireLast: false } }],
       errors: [
         {
@@ -2165,13 +2170,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none' } }],
       errors: [
         {
@@ -2192,13 +2197,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: true } }],
       errors: [
         {
@@ -2219,13 +2224,13 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -2241,13 +2246,13 @@ type Foo = {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -2263,13 +2268,13 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none' } }],
       errors: [
         {
@@ -2290,13 +2295,13 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: true } }],
       errors: [
         {
@@ -2317,13 +2322,13 @@ type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -2339,13 +2344,13 @@ type Foo = {
     name: string
     age: number,
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'none', requireLast: false } }],
       errors: [
         {
@@ -2361,13 +2366,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma' },
@@ -2395,13 +2400,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: false },
@@ -2431,13 +2436,13 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: false },
@@ -2462,13 +2467,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -2496,13 +2501,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -2535,13 +2540,13 @@ type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -2569,13 +2574,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -2603,13 +2608,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -2642,13 +2647,13 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -2676,13 +2681,13 @@ type Foo = {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -2715,13 +2720,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi' },
@@ -2749,13 +2754,13 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: false },
@@ -2785,13 +2790,13 @@ type Foo = {
     name: string;
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -2819,13 +2824,13 @@ type Foo = {
     name: string
     age: number;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'semi', requireLast: true },
@@ -2853,13 +2858,13 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma' },
@@ -2887,13 +2892,13 @@ type Foo = {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: false },
@@ -2923,13 +2928,13 @@ type Foo = {
     name: string,
     age: number
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: true },
@@ -2957,13 +2962,13 @@ type Foo = {
     name: string
     age: number,
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string
     age: number
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: true },
@@ -2996,7 +3001,7 @@ type Bar = {
     name: string,
     age: number,
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string,
@@ -3007,7 +3012,7 @@ type Bar = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'none', requireLast: true },
@@ -3045,12 +3050,12 @@ type Bar = {
 interface Foo {
     [key: string]: any
 }
-            `,
+      `,
       output: `
 interface Foo {
     [key: string]: any;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSemi',
@@ -3064,12 +3069,12 @@ interface Foo {
 interface Foo {
     [key: string]: any
 }
-            `,
+      `,
       output: `
 interface Foo {
     [key: string]: any;
 }
-            `,
+      `,
       options: [{ singleline: { delimiter: 'comma' } }],
       errors: [
         {
@@ -3143,12 +3148,12 @@ interface Foo {
 type Foo = {
     [key: string]: any
 }
-            `,
+      `,
       output: `
 type Foo = {
     [key: string]: any;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSemi',
@@ -3162,12 +3167,12 @@ type Foo = {
 type Foo = {
     [key: string]: any
 }
-            `,
+      `,
       output: `
 type Foo = {
     [key: string]: any;
 }
-            `,
+      `,
       options: [{ singleline: { delimiter: 'semi' } }],
       errors: [
         {
@@ -3232,7 +3237,7 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: false } }],
       errors: [
         {
@@ -3248,7 +3253,7 @@ interface Foo {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: true },
@@ -3286,7 +3291,7 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [{ multiline: { delimiter: 'semi', requireLast: false } }],
       errors: [
         {
@@ -3302,7 +3307,7 @@ type Foo = {
     name: string;
     age: number;
 }
-            `,
+      `,
       options: [
         {
           multiline: { delimiter: 'comma', requireLast: true },
diff --git a/packages/eslint-plugin/tests/rules/member-naming.test.ts b/packages/eslint-plugin/tests/rules/member-naming.test.ts
index 851d70ea706..e3befcffbe1 100644
--- a/packages/eslint-plugin/tests/rules/member-naming.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-naming.test.ts
@@ -8,42 +8,72 @@ const ruleTester = new RuleTester({
 ruleTester.run('member-naming', rule, {
   valid: [
     {
-      code: `class Class { _fooBar() {} }`,
+      code: `
+class Class {
+  _fooBar() {}
+}
+      `,
       options: [{ public: '^_' }],
     },
     {
-      code: `class Class { private constructor(); _fooBar() {} }`,
+      code: `
+class Class {
+  private constructor();
+  _fooBar() {}
+}
+      `,
       options: [{ private: '^_' }],
     },
     {
-      code: `class Class { constructor() {}; _fooBar() {} }`,
+      code: `
+class Class {
+  constructor() {}
+  _fooBar() {}
+}
+      `,
       options: [{ public: '^_' }],
     },
     {
-      code: `class Class { public _fooBar() {} }`,
+      code: `
+class Class {
+  public _fooBar() {}
+}
+      `,
       options: [{ public: '^_' }],
     },
     {
-      code: `class Class { protected _fooBar() {} }`,
+      code: `
+class Class {
+  protected _fooBar() {}
+}
+      `,
       options: [{ protected: '^_' }],
     },
     {
-      code: `class Class { private _fooBar() {} }`,
+      code: `
+class Class {
+  private _fooBar() {}
+}
+      `,
       options: [{ private: '^_' }],
     },
     {
-      code: `class Class { protected fooBar() {} }`,
+      code: `
+class Class {
+  protected fooBar() {}
+}
+      `,
       options: [{ private: '^_' }],
     },
     {
       code: `
 class Class {
-    pubOne() {}
-    public pubTwo() {}
-    protected protThree() {}
-    private privFour() {}
+  pubOne() {}
+  public pubTwo() {}
+  protected protThree() {}
+  private privFour() {}
 }
-            `,
+      `,
       options: [
         {
           public: '^pub[A-Z]',
@@ -55,12 +85,12 @@ class Class {
     {
       code: `
 class Class {
-    pubOne: string;
-    public pubTwo: string;
-    protected protThree: string;
-    private privFour: string;
+  pubOne: string;
+  public pubTwo: string;
+  protected protThree: string;
+  private privFour: string;
 }
-            `,
+      `,
       options: [
         {
           public: '^pub[A-Z]',
@@ -72,12 +102,12 @@ class Class {
     {
       code: `
 class Class {
-    pubOne = true;
-    public pubTwo = true;
-    protected protThree = true;
-    private privFour = true;
+  pubOne = true;
+  public pubTwo = true;
+  protected protThree = true;
+  private privFour = true;
 }
-            `,
+      `,
       options: [
         {
           public: '^pub[A-Z]',
@@ -90,7 +120,11 @@ class Class {
     {
       code: `
 class Test {
-    constructor(public __a: string, protected __b: string, private __c: string = 100) {}
+  constructor(
+    public __a: string,
+    protected __b: string,
+    private __c: string = 100,
+  ) {}
 }
       `,
       options: [
@@ -106,14 +140,18 @@ class Test {
         // Semantically invalid test case, TS has to throw an error.
         `
 class Foo {
-    constructor(private ...name: string[], private [test]: [string]) {}
+  constructor(private ...name: string[], private [test]: [string]) {}
 }
-      `,
+        `,
     },
   ],
   invalid: [
     {
-      code: `class Class { fooBar() {} }`,
+      code: `
+class Class {
+  fooBar() {}
+}
+      `,
       options: [{ public: '^_' }],
       errors: [
         {
@@ -123,13 +161,17 @@ class Foo {
             convention: '/^_/',
             name: 'fooBar',
           },
-          line: 1,
-          column: 15,
+          line: 3,
+          column: 3,
         },
       ],
     },
     {
-      code: `class Class { public fooBar() {} }`,
+      code: `
+class Class {
+  public fooBar() {}
+}
+      `,
       options: [{ public: '^_' }],
       errors: [
         {
@@ -139,13 +181,17 @@ class Foo {
             convention: '/^_/',
             name: 'fooBar',
           },
-          line: 1,
-          column: 22,
+          line: 3,
+          column: 10,
         },
       ],
     },
     {
-      code: `class Class { protected fooBar() {} }`,
+      code: `
+class Class {
+  protected fooBar() {}
+}
+      `,
       options: [{ protected: '^_' }],
       errors: [
         {
@@ -155,13 +201,17 @@ class Foo {
             convention: '/^_/',
             name: 'fooBar',
           },
-          line: 1,
-          column: 25,
+          line: 3,
+          column: 13,
         },
       ],
     },
     {
-      code: `class Class { private fooBar() {} }`,
+      code: `
+class Class {
+  private fooBar() {}
+}
+      `,
       options: [{ private: '^_' }],
       errors: [
         {
@@ -171,20 +221,20 @@ class Foo {
             convention: '/^_/',
             name: 'fooBar',
           },
-          line: 1,
-          column: 23,
+          line: 3,
+          column: 11,
         },
       ],
     },
     {
       code: `
 class Class {
-    one() {}
-    public two() {}
-    protected three() {}
-    private four() {}
+  one() {}
+  public two() {}
+  protected three() {}
+  private four() {}
 }
-            `,
+      `,
       options: [
         {
           public: '^pub[A-Z]',
@@ -201,7 +251,7 @@ class Class {
             name: 'one',
           },
           line: 3,
-          column: 5,
+          column: 3,
         },
         {
           messageId: 'incorrectName',
@@ -211,7 +261,7 @@ class Class {
             name: 'two',
           },
           line: 4,
-          column: 12,
+          column: 10,
         },
         {
           messageId: 'incorrectName',
@@ -221,7 +271,7 @@ class Class {
             name: 'three',
           },
           line: 5,
-          column: 15,
+          column: 13,
         },
         {
           messageId: 'incorrectName',
@@ -231,19 +281,19 @@ class Class {
             name: 'four',
           },
           line: 6,
-          column: 13,
+          column: 11,
         },
       ],
     },
     {
       code: `
 class Class {
-    one: string;
-    public two: string;
-    protected three: string;
-    private four: string;
+  one: string;
+  public two: string;
+  protected three: string;
+  private four: string;
 }
-            `,
+      `,
       options: [
         {
           public: '^pub[A-Z]',
@@ -260,7 +310,7 @@ class Class {
             name: 'one',
           },
           line: 3,
-          column: 5,
+          column: 3,
         },
         {
           messageId: 'incorrectName',
@@ -270,7 +320,7 @@ class Class {
             name: 'two',
           },
           line: 4,
-          column: 12,
+          column: 10,
         },
         {
           messageId: 'incorrectName',
@@ -280,7 +330,7 @@ class Class {
             name: 'three',
           },
           line: 5,
-          column: 15,
+          column: 13,
         },
         {
           messageId: 'incorrectName',
@@ -290,19 +340,19 @@ class Class {
             name: 'four',
           },
           line: 6,
-          column: 13,
+          column: 11,
         },
       ],
     },
     {
       code: `
 class Class {
-    one = true;
-    public two = true;
-    protected three = true;
-    private four = true;
+  one = true;
+  public two = true;
+  protected three = true;
+  private four = true;
 }
-            `,
+      `,
       options: [
         {
           public: '^pub[A-Z]',
@@ -319,7 +369,7 @@ class Class {
             name: 'one',
           },
           line: 3,
-          column: 5,
+          column: 3,
         },
         {
           messageId: 'incorrectName',
@@ -329,7 +379,7 @@ class Class {
             name: 'two',
           },
           line: 4,
-          column: 12,
+          column: 10,
         },
         {
           messageId: 'incorrectName',
@@ -339,7 +389,7 @@ class Class {
             name: 'three',
           },
           line: 5,
-          column: 15,
+          column: 13,
         },
         {
           messageId: 'incorrectName',
@@ -349,14 +399,14 @@ class Class {
             name: 'four',
           },
           line: 6,
-          column: 13,
+          column: 11,
         },
       ],
     },
     {
       code: `
 class Test {
-    constructor(public a: string, protected b: string, private c: string = 100) {}
+  constructor(public a: string, protected b: string, private c: string = 100) {}
 }
       `,
       options: [
@@ -375,7 +425,7 @@ class Test {
             name: 'a',
           },
           line: 3,
-          column: 24,
+          column: 22,
         },
         {
           messageId: 'incorrectName',
@@ -385,7 +435,7 @@ class Test {
             name: 'b',
           },
           line: 3,
-          column: 45,
+          column: 43,
         },
         {
           messageId: 'incorrectName',
@@ -395,7 +445,7 @@ class Test {
             name: 'c',
           },
           line: 3,
-          column: 64,
+          column: 62,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/member-ordering.test.ts b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
index 5307793c3d7..ddea73e8d1d 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
@@ -1,3 +1,6 @@
+// TODO - migrate this test to the rule
+/* eslint-disable @typescript-eslint/internal/plugin-test-formatting */
+
 import rule from '../../src/rules/member-ordering';
 import { RuleTester } from '../RuleTester';
 
diff --git a/packages/eslint-plugin/tests/rules/naming-convention.test.ts b/packages/eslint-plugin/tests/rules/naming-convention.test.ts
index 0df5f73d487..b4326c8fe75 100644
--- a/packages/eslint-plugin/tests/rules/naming-convention.test.ts
+++ b/packages/eslint-plugin/tests/rules/naming-convention.test.ts
@@ -608,7 +608,7 @@ const cases: Cases = [
 
 ruleTester.run('naming-convention', rule, {
   valid: [
-    `const x = 1;`, // no options shouldn't crash
+    'const x = 1;', // no options shouldn't crash
     ...createValidTestCases(cases),
     {
       code: `
@@ -825,10 +825,14 @@ ruleTester.run('naming-convention', rule, {
     },
     {
       code: `
-        declare const function_camelCase1: (() => void);
+        declare const function_camelCase1: () => void;
         declare const function_camelCase2: (() => void) | null;
         declare const function_camelCase3: (() => void) | null | undefined;
-        declare const function_camelCase4: (() => void) | (() => string) | null | undefined;
+        declare const function_camelCase4:
+          | (() => void)
+          | (() => string)
+          | null
+          | undefined;
       `,
       options: [
         {
@@ -847,11 +851,20 @@ ruleTester.run('naming-convention', rule, {
         declare const array_camelCase2: ReadonlyArray<number> | null;
         declare const array_camelCase3: number[] | null | undefined;
         declare const array_camelCase4: readonly number[] | null | undefined;
-        declare const array_camelCase5: number[] | (number | string)[] | null | undefined;
+        declare const array_camelCase5:
+          | number[]
+          | (number | string)[]
+          | null
+          | undefined;
         declare const array_camelCase6: [] | null | undefined;
         declare const array_camelCase7: [number] | null | undefined;
 
-        declare const array_camelCase8: readonly number[] | Array<string> | [boolean] | null | undefined;
+        declare const array_camelCase8:
+          | readonly number[]
+          | Array<string>
+          | [boolean]
+          | null
+          | undefined;
       `,
       options: [
         {
diff --git a/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts b/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
index cc6530085dd..af760d29999 100644
--- a/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-array-constructor.test.ts
@@ -10,38 +10,38 @@ const messageId = 'useLiteral' as const;
 
 ruleTester.run('no-array-constructor', rule, {
   valid: [
-    'new Array(x)',
-    'Array(x)',
-    'new Array(9)',
-    'Array(9)',
-    'new foo.Array()',
-    'foo.Array()',
-    'new Array.foo',
-    'Array.foo()',
+    'new Array(x);',
+    'Array(x);',
+    'new Array(9);',
+    'Array(9);',
+    'new foo.Array();',
+    'foo.Array();',
+    'new Array.foo();',
+    'Array.foo();',
 
     // TypeScript
-    'new Array<Foo>(1, 2, 3)',
-    'new Array<Foo>()',
-    'Array<Foo>(1, 2, 3)',
-    'Array<Foo>()',
+    'new Array<Foo>(1, 2, 3);',
+    'new Array<Foo>();',
+    'Array<Foo>(1, 2, 3);',
+    'Array<Foo>();',
 
     // optional chain
-    'Array?.(x)',
-    'Array?.(9)',
-    'foo?.Array()',
-    'Array?.foo()',
-    'foo.Array?.()',
-    'Array.foo?.()',
-    'Array?.<Foo>(1, 2, 3)',
-    'Array?.<Foo>()',
-    'Array?.(0, 1, 2)',
-    'Array?.(x, y)',
+    'Array?.(x);',
+    'Array?.(9);',
+    'foo?.Array();',
+    'Array?.foo();',
+    'foo.Array?.();',
+    'Array.foo?.();',
+    'Array?.<Foo>(1, 2, 3);',
+    'Array?.<Foo>();',
+    'Array?.(0, 1, 2);',
+    'Array?.(x, y);',
   ],
 
   invalid: [
     {
-      code: 'new Array()',
-      output: '[]',
+      code: 'new Array();',
+      output: '[];',
       errors: [
         {
           messageId,
@@ -50,8 +50,8 @@ ruleTester.run('no-array-constructor', rule, {
       ],
     },
     {
-      code: 'Array()',
-      output: '[]',
+      code: 'Array();',
+      output: '[];',
       errors: [
         {
           messageId,
@@ -60,8 +60,8 @@ ruleTester.run('no-array-constructor', rule, {
       ],
     },
     {
-      code: 'new Array',
-      output: '[]',
+      code: 'new Array(x, y);',
+      output: '[x, y];',
       errors: [
         {
           messageId,
@@ -70,18 +70,8 @@ ruleTester.run('no-array-constructor', rule, {
       ],
     },
     {
-      code: 'new Array(x, y)',
-      output: '[x, y]',
-      errors: [
-        {
-          messageId,
-          type: AST_NODE_TYPES.NewExpression,
-        },
-      ],
-    },
-    {
-      code: 'Array(x, y)',
-      output: '[x, y]',
+      code: 'Array(x, y);',
+      output: '[x, y];',
       errors: [
         {
           messageId,
@@ -90,8 +80,8 @@ ruleTester.run('no-array-constructor', rule, {
       ],
     },
     {
-      code: 'new Array(0, 1, 2)',
-      output: '[0, 1, 2]',
+      code: 'new Array(0, 1, 2);',
+      output: '[0, 1, 2];',
       errors: [
         {
           messageId,
@@ -100,8 +90,8 @@ ruleTester.run('no-array-constructor', rule, {
       ],
     },
     {
-      code: 'Array(0, 1, 2)',
-      output: '[0, 1, 2]',
+      code: 'Array(0, 1, 2);',
+      output: '[0, 1, 2];',
       errors: [
         {
           messageId,
@@ -110,16 +100,12 @@ ruleTester.run('no-array-constructor', rule, {
       ],
     },
     {
-      code: `new Array(
-                0,
-                1,
-                2
-            )`,
-      output: `[
-                0,
-                1,
-                2
-            ]`,
+      code: `
+new Array(0, 1, 2);
+      `,
+      output: `
+[0, 1, 2];
+      `,
       errors: [
         {
           messageId,
diff --git a/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts b/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts
index 3be0828791d..cd2e4b166a9 100644
--- a/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts
@@ -13,53 +13,67 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-base-to-string', rule, {
   valid: [
-    `\`\${""}\``,
-    `\`\${true}\``,
-    `\`\${[]}\``,
-    `\`\${function () {}}\``,
-    `"" + ""`,
-    `"" + true`,
-    `"" + []`,
-    `true + true`,
-    `true + ""`,
-    `true + []`,
-    `[] + []`,
-    `[] + true`,
-    `[] + ""`,
-    `({}).constructor()`,
-    `"text".toString()`,
-    `false.toString()`,
-    `let value = 1;
-        value.toString()`,
-    `let value = 1n;
-        value.toString()`,
-    `function someFunction() { }
-        someFunction.toString();`,
-    'unknownObject.toString()',
-    'unknownObject.someOtherMethod()',
+    "`${''}`;",
+    '`${true}`;',
+    '`${[]}`;',
+    '`${function() {}}`;',
+    "'' + '';",
+    "'' + true;",
+    "'' + [];",
+    'true + true;',
+    "true + '';",
+    'true + [];',
+    '[] + [];',
+    '[] + true;',
+    "[] + '';",
+    '({}.constructor());',
+    "'text'.toString();",
+    'false.toString();',
+    `
+let value = 1;
+value.toString();
+    `,
+    `
+let value = 1n;
+value.toString();
+    `,
+    `
+function someFunction() {}
+someFunction.toString();
+    `,
+    'unknownObject.toString();',
+    'unknownObject.someOtherMethod();',
     '(() => {}).toString();',
-    `class CustomToString { toString() { return "Hello, world!"; } }
-      "" + (new CustomToString());`,
-    `const literalWithToString = {
-      toString: () => "Hello, world!",
-    };
-    "" + literalToString;`,
-    `let _ = {} * {}`,
-    `let _ = {} / {}`,
-    `let _ = {} *= {}`,
-    `let _ = {} /= {}`,
-    `let _ = {} = {}`,
-    `let _ = {} == {}`,
-    `let _ = {} === {}`,
-    `let _ = {} in {}`,
-    `let _ = {} & {}`,
-    `let _ = {} ^ {}`,
-    `let _ = {} << {}`,
-    `let _ = {} >> {}`,
+    `
+class CustomToString {
+  toString() {
+    return 'Hello, world!';
+  }
+}
+'' + new CustomToString();
+    `,
+    `
+const literalWithToString = {
+  toString: () => 'Hello, world!',
+};
+'' + literalToString;
+    `,
+    'let _ = {} * {};',
+    'let _ = {} / {};',
+    'let _ = ({} *= {});',
+    'let _ = ({} /= {});',
+    'let _ = ({} = {});',
+    'let _ = {} == {};',
+    'let _ = {} === {};',
+    'let _ = {} in {};',
+    'let _ = {} & {};',
+    'let _ = {} ^ {};',
+    'let _ = {} << {};',
+    'let _ = {} >> {};',
   ],
   invalid: [
     {
-      code: `\`\${{}})\``,
+      code: '`${{}})`;',
       errors: [
         {
           data: {
@@ -71,7 +85,7 @@ ruleTester.run('no-base-to-string', rule, {
       ],
     },
     {
-      code: `({}).toString()`,
+      code: '({}.toString());',
       errors: [
         {
           data: {
@@ -83,7 +97,7 @@ ruleTester.run('no-base-to-string', rule, {
       ],
     },
     {
-      code: `"" + {}`,
+      code: "'' + {};",
       errors: [
         {
           data: {
@@ -95,7 +109,7 @@ ruleTester.run('no-base-to-string', rule, {
       ],
     },
     {
-      code: `"" += {}`,
+      code: "'' += {};",
       errors: [
         {
           data: {
@@ -108,7 +122,7 @@ ruleTester.run('no-base-to-string', rule, {
     },
     {
       code: `
-        let someObjectOrString = Math.random() ? { a: true } : "text";
+        let someObjectOrString = Math.random() ? { a: true } : 'text';
         someObjectOrString.toString();
       `,
       errors: [
@@ -123,8 +137,8 @@ ruleTester.run('no-base-to-string', rule, {
     },
     {
       code: `
-        let someObjectOrString = Math.random() ? { a: true } : "text";
-        someObjectOrString + "";
+        let someObjectOrString = Math.random() ? { a: true } : 'text';
+        someObjectOrString + '';
       `,
       errors: [
         {
@@ -154,7 +168,7 @@ ruleTester.run('no-base-to-string', rule, {
     {
       code: `
         let someObjectOrObject = Math.random() ? { a: true, b: true } : { a: true };
-        someObjectOrObject + "";
+        someObjectOrObject + '';
       `,
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/no-dupe-class-members.test.ts b/packages/eslint-plugin/tests/rules/no-dupe-class-members.test.ts
index 72430c6e39b..50cbdba5410 100644
--- a/packages/eslint-plugin/tests/rules/no-dupe-class-members.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-dupe-class-members.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/no-dupe-class-members';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -7,16 +7,72 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-dupe-class-members', rule, {
   valid: [
-    'class A { foo() {} bar() {} }',
-    'class A { static foo() {} foo() {} }',
-    'class A { get foo() {} set foo(value) {} }',
-    'class A { static foo() {} get foo() {} set foo(value) {} }',
-    'class A { foo() { } } class B { foo() { } }',
-    'class A { [foo]() {} foo() {} }',
-    "class A { 'foo'() {} 'bar'() {} baz() {} }",
-    "class A { *'foo'() {} *'bar'() {} *baz() {} }",
-    "class A { get 'foo'() {} get 'bar'() {} get baz() {} }",
-    'class A { 1() {} 2() {} }',
+    `
+class A {
+  foo() {}
+  bar() {}
+}
+    `,
+    `
+class A {
+  static foo() {}
+  foo() {}
+}
+    `,
+    `
+class A {
+  get foo() {}
+  set foo(value) {}
+}
+    `,
+    `
+class A {
+  static foo() {}
+  get foo() {}
+  set foo(value) {}
+}
+    `,
+    `
+class A {
+  foo() {}
+}
+class B {
+  foo() {}
+}
+    `,
+    `
+class A {
+  [foo]() {}
+  foo() {}
+}
+    `,
+    `
+class A {
+  foo() {}
+  bar() {}
+  baz() {}
+}
+    `,
+    `
+class A {
+  *foo() {}
+  *bar() {}
+  *baz() {}
+}
+    `,
+    `
+class A {
+  get foo() {}
+  get bar() {}
+  get baz() {}
+}
+    `,
+    `
+class A {
+  1() {}
+  2() {}
+}
+    `,
     `
       class Foo {
         foo(a: string): string;
@@ -27,52 +83,93 @@ ruleTester.run('no-dupe-class-members', rule, {
   ],
   invalid: [
     {
-      code: 'class A { foo() {} foo() {} }',
+      code: `
+class A {
+  foo() {}
+  foo() {}
+}
+      `,
       errors: [
-        { line: 1, column: 20, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
       ],
     },
     {
-      code: '!class A { foo() {} foo() {} };',
+      code: `
+!class A {
+  foo() {}
+  foo() {}
+};
+      `,
       errors: [
-        { line: 1, column: 21, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
       ],
     },
     {
-      code: "class A { 'foo'() {} 'foo'() {} }",
+      code: noFormat`
+class A {
+  'foo'() {}
+  'foo'() {}
+}
+      `,
       errors: [
-        { line: 1, column: 22, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
       ],
     },
     {
-      code: 'class A { 10() {} 1e1() {} }',
+      code: `
+class A {
+  10() {}
+  1e1() {}
+}
+      `,
       errors: [
-        { line: 1, column: 19, messageId: 'unexpected', data: { name: '10' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: '10' } },
       ],
     },
     {
-      code: 'class A { foo() {} foo() {} foo() {} }',
+      code: `
+class A {
+  foo() {}
+  foo() {}
+  foo() {}
+}
+      `,
       errors: [
-        { line: 1, column: 20, messageId: 'unexpected', data: { name: 'foo' } },
-        { line: 1, column: 29, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 5, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
       ],
     },
     {
-      code: 'class A { static foo() {} static foo() {} }',
+      code: `
+class A {
+  static foo() {}
+  static foo() {}
+}
+      `,
       errors: [
-        { line: 1, column: 27, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
       ],
     },
     {
-      code: 'class A { foo() {} get foo() {} }',
+      code: `
+class A {
+  foo() {}
+  get foo() {}
+}
+      `,
       errors: [
-        { line: 1, column: 20, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
       ],
     },
     {
-      code: 'class A { set foo(value) {} foo() {} }',
+      code: `
+class A {
+  set foo(value) {}
+  foo() {}
+}
+      `,
       errors: [
-        { line: 1, column: 29, messageId: 'unexpected', data: { name: 'foo' } },
+        { line: 4, column: 3, messageId: 'unexpected', data: { name: 'foo' } },
       ],
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts b/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
index 5a88fbff10c..798971e90f1 100644
--- a/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-dynamic-delete.test.ts
@@ -13,114 +13,158 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-dynamic-delete', rule, {
   valid: [
-    `const container: { [i: string]: 0 } = {};
-      delete container.aaa;`,
-    `const container: { [i: string]: 0 } = {};
-      delete container.delete;`,
-    `const container: { [i: string]: 0 } = {};
-      delete container[7];`,
-    `const container: { [i: string]: 0 } = {};
-      delete container[-7];`,
-    `const container: { [i: string]: 0 } = {};
-      delete container[+7];`,
-    `const container: { [i: string]: 0 } = {};
-      delete container['-Infinity'];`,
-    `const container: { [i: string]: 0 } = {};
-      delete container['+Infinity'];`,
-    `const value = 1;
-      delete value;`,
-    `const value = 1;
-      delete -value;`,
+    `
+const container: { [i: string]: 0 } = {};
+delete container.aaa;
+    `,
+    `
+const container: { [i: string]: 0 } = {};
+delete container.delete;
+    `,
+    `
+const container: { [i: string]: 0 } = {};
+delete container[7];
+    `,
+    `
+const container: { [i: string]: 0 } = {};
+delete container[-7];
+    `,
+    `
+const container: { [i: string]: 0 } = {};
+delete container[+7];
+    `,
+    `
+const container: { [i: string]: 0 } = {};
+delete container['-Infinity'];
+    `,
+    `
+const container: { [i: string]: 0 } = {};
+delete container['+Infinity'];
+    `,
+    `
+const value = 1;
+delete value;
+    `,
+    `
+const value = 1;
+delete -value;
+    `,
   ],
   invalid: [
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container['aaa'];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+delete container['aaa'];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container.aaa;`,
+      output: `
+const container: { [i: string]: 0 } = {};
+delete container.aaa;
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container [  'aaa'   ] ;`,
+      code: `
+const container: { [i: string]: 0 } = {};
+delete container['aa' + 'b'];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container .aaa ;`,
+      output: `
+const container: { [i: string]: 0 } = {};
+delete container['aa' + 'b'];
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container['aa' + 'b'];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+delete container['delete'];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container['aa' + 'b'];`,
+      output: `
+const container: { [i: string]: 0 } = {};
+delete container.delete;
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container['delete'];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+delete container[-Infinity];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container.delete;`,
+      output: `
+const container: { [i: string]: 0 } = {};
+delete container[-Infinity];
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container[-Infinity];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+delete container[+Infinity];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container[-Infinity];`,
+      output: `
+const container: { [i: string]: 0 } = {};
+delete container[+Infinity];
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container[+Infinity];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+delete container[NaN];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container[+Infinity];`,
+      output: `
+const container: { [i: string]: 0 } = {};
+delete container[NaN];
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container[NaN];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+delete container['NaN'];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container[NaN];`,
+      output: `
+const container: { [i: string]: 0 } = {};
+delete container.NaN;
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container['NaN'];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+const name = 'name';
+delete container[name];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container.NaN;`,
+      output: `
+const container: { [i: string]: 0 } = {};
+const name = 'name';
+delete container[name];
+      `,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        delete container    [   'NaN'  ] ;`,
+      code: `
+const container: { [i: string]: 0 } = {};
+const getName = () => 'aaa';
+delete container[getName()];
+      `,
+      output: `
+const container: { [i: string]: 0 } = {};
+const getName = () => 'aaa';
+delete container[getName()];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        delete container    .NaN ;`,
     },
     {
-      code: `const container: { [i: string]: 0 } = {};
-        const name = 'name';
-        delete container[name];`,
-      errors: [{ messageId: 'dynamicDelete' }],
-      output: `const container: { [i: string]: 0 } = {};
-        const name = 'name';
-        delete container[name];`,
-    },
-    {
-      code: `const container: { [i: string]: 0 } = {};
-        const getName = () => 'aaa';
-        delete container[getName()];`,
-      output: `const container: { [i: string]: 0 } = {};
-        const getName = () => 'aaa';
-        delete container[getName()];`,
-      errors: [{ messageId: 'dynamicDelete' }],
-    },
-    {
-      code: `const container: { [i: string]: 0 } = {};
-        const name = { foo: { bar: 'bar' } };
-        delete container[name.foo.bar];`,
-      output: `const container: { [i: string]: 0 } = {};
-        const name = { foo: { bar: 'bar' } };
-        delete container[name.foo.bar];`,
+      code: `
+const container: { [i: string]: 0 } = {};
+const name = { foo: { bar: 'bar' } };
+delete container[name.foo.bar];
+      `,
+      output: `
+const container: { [i: string]: 0 } = {};
+const name = { foo: { bar: 'bar' } };
+delete container[name.foo.bar];
+      `,
       errors: [{ messageId: 'dynamicDelete' }],
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/no-empty-function.test.ts b/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
index 9b5ad3507d3..9ec4d3c3097 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-function.test.ts
@@ -8,28 +8,36 @@ const ruleTester = new RuleTester({
 ruleTester.run('no-empty-function', rule, {
   valid: [
     {
-      code: `class Person {
-        private name: string
-        constructor(name: string) {
-          this.name = name;
-        }
-      }`,
+      code: `
+class Person {
+  private name: string;
+  constructor(name: string) {
+    this.name = name;
+  }
+}
+      `,
     },
     {
-      code: `class Person {
-        constructor(private name: string) {}
-      }`,
+      code: `
+class Person {
+  constructor(private name: string) {}
+}
+      `,
     },
     {
-      code: `class Person {
-        constructor(name: string) {}
-      }`,
+      code: `
+class Person {
+  constructor(name: string) {}
+}
+      `,
       options: [{ allow: ['constructors'] }],
     },
     {
-      code: `class Person {
-        otherMethod(name: string) {}
-      }`,
+      code: `
+class Person {
+  otherMethod(name: string) {}
+}
+      `,
       options: [{ allow: ['methods'] }],
     },
     {
@@ -59,32 +67,36 @@ function foo() {
 
   invalid: [
     {
-      code: `class Person {
-        constructor(name: string) {}
-      }`,
+      code: `
+class Person {
+  constructor(name: string) {}
+}
+      `,
       errors: [
         {
           messageId: 'unexpected',
           data: {
             name: 'constructor',
           },
-          line: 2,
-          column: 35,
+          line: 3,
+          column: 29,
         },
       ],
     },
     {
-      code: `class Person {
-        otherMethod(name: string) {}
-      }`,
+      code: `
+class Person {
+  otherMethod(name: string) {}
+}
+      `,
       errors: [
         {
           messageId: 'unexpected',
           data: {
             name: "method 'otherMethod'",
           },
-          line: 2,
-          column: 35,
+          line: 3,
+          column: 29,
         },
       ],
     },
@@ -124,8 +136,7 @@ class Foo {
     },
     {
       code: `
-function foo() {
-}
+function foo() {}
       `,
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
index f02d753dee1..1a69e06f140 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/no-empty-interface';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -9,29 +9,29 @@ ruleTester.run('no-empty-interface', rule, {
   valid: [
     `
 interface Foo {
-    name: string;
+  name: string;
 }
-        `,
+    `,
     `
 interface Foo {
-    name: string;
+  name: string;
 }
 
 interface Bar {
-    age: number;
+  age: number;
 }
 
 // valid because extending multiple interfaces can be used instead of a union type
 interface Baz extends Foo, Bar {}
-        `,
+    `,
     {
       code: `
 interface Foo {
-    name: string;
+  name: string;
 }
 
 interface Bar extends Foo {}
-        `,
+      `,
       options: [{ allowSingleExtends: true }],
     },
   ],
@@ -47,7 +47,7 @@ interface Bar extends Foo {}
       ],
     },
     {
-      code: 'interface Foo extends {}',
+      code: noFormat`interface Foo extends {}`,
       errors: [
         {
           messageId: 'noEmpty',
@@ -59,11 +59,11 @@ interface Bar extends Foo {}
     {
       code: `
 interface Foo {
-    name: string;
+  name: string;
 }
 
 interface Bar extends Foo {}
-            `,
+      `,
       options: [{ allowSingleExtends: false }],
       errors: [
         {
@@ -75,7 +75,7 @@ interface Bar extends Foo {}
     },
     {
       code: 'interface Foo extends Array<number> {}',
-      output: 'type Foo = Array<number>',
+      output: noFormat`type Foo = Array<number>`,
       errors: [
         {
           messageId: 'noEmptyWithSuper',
@@ -85,8 +85,8 @@ interface Bar extends Foo {}
       ],
     },
     {
-      code: 'interface Foo extends Array<number | {}> { }',
-      output: 'type Foo = Array<number | {}>',
+      code: 'interface Foo extends Array<number | {}> {}',
+      output: noFormat`type Foo = Array<number | {}>`,
       errors: [
         {
           messageId: 'noEmptyWithSuper',
@@ -101,13 +101,13 @@ interface Bar {
   bar: string;
 }
 interface Foo extends Array<Bar> {}
-`,
-      output: `
+      `,
+      output: noFormat`
 interface Bar {
   bar: string;
 }
 type Foo = Array<Bar>
-`,
+      `,
       errors: [
         {
           messageId: 'noEmptyWithSuper',
@@ -119,10 +119,12 @@ type Foo = Array<Bar>
     {
       code: `
 type R = Record<string, unknown>;
-interface Foo extends R {   };`,
-      output: `
+interface Foo extends R {}
+      `,
+      output: noFormat`
 type R = Record<string, unknown>;
-type Foo = R;`,
+type Foo = R
+      `,
       errors: [
         {
           messageId: 'noEmptyWithSuper',
diff --git a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
index fa68b09919e..dde8b938175 100644
--- a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
@@ -11,7 +11,7 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-explicit-any', rule, {
   valid: [
-    'const number: number = 1',
+    'const number: number = 1;',
     'function greet(): string {}',
     'function greet(): Array<string> {}',
     'function greet(): string[] {}',
@@ -20,119 +20,119 @@ ruleTester.run('no-explicit-any', rule, {
     'function greet(param: Array<string>): Array<string> {}',
     `
 class Greeter {
-    message: string;
+  message: string;
 }
-        `,
+    `,
     `
 class Greeter {
-    message: Array<string>;
+  message: Array<string>;
 }
-        `,
+    `,
     `
 class Greeter {
-    message: string[];
+  message: string[];
 }
-        `,
+    `,
     `
 class Greeter {
-    message: Array<Array<string>>;
+  message: Array<Array<string>>;
 }
-        `,
+    `,
     `
 class Greeter {
-    message: Array<string[]>;
+  message: Array<string[]>;
 }
-        `,
+    `,
     `
 interface Greeter {
-    message: string;
+  message: string;
 }
-        `,
+    `,
     `
 interface Greeter {
-    message: Array<string>;
+  message: Array<string>;
 }
-        `,
+    `,
     `
 interface Greeter {
-    message: string[];
+  message: string[];
 }
-        `,
+    `,
     `
 interface Greeter {
-    message: Array<Array<string>>;
+  message: Array<Array<string>>;
 }
-        `,
+    `,
     `
 interface Greeter {
-    message: Array<string[]>;
+  message: Array<string[]>;
 }
-        `,
+    `,
     `
 type obj = {
-    message: string;
-}
-        `,
+  message: string;
+};
+    `,
     `
 type obj = {
-    message: Array<string>;
-}
-        `,
+  message: Array<string>;
+};
+    `,
     `
 type obj = {
-    message: string[];
-}
-        `,
+  message: string[];
+};
+    `,
     `
 type obj = {
-    message: Array<Array<string>>;
-}
-        `,
+  message: Array<Array<string>>;
+};
+    `,
     `
 type obj = {
-    message: Array<string[]>;
-}
-        `,
+  message: Array<string[]>;
+};
+    `,
     `
 type obj = {
-    message: string | number;
-}
-        `,
+  message: string | number;
+};
+    `,
     `
 type obj = {
-    message: string | Array<string>;
-}
-        `,
+  message: string | Array<string>;
+};
+    `,
     `
 type obj = {
-    message: string | string[];
-}
-        `,
+  message: string | string[];
+};
+    `,
     `
 type obj = {
-    message: string | Array<Array<string>>;
-}
-        `,
+  message: string | Array<Array<string>>;
+};
+    `,
     `
 type obj = {
-    message: string & number;
-}
-        `,
+  message: string & number;
+};
+    `,
     `
 type obj = {
-    message: string & Array<string>;
-}
-        `,
+  message: string & Array<string>;
+};
+    `,
     `
 type obj = {
-    message: string & string[];
-}
-        `,
+  message: string & string[];
+};
+    `,
     `
 type obj = {
-    message: string & Array<Array<string>>;
-}
-        `,
+  message: string & Array<Array<string>>;
+};
+    `,
     // https://github.com/eslint/typescript-eslint-parser/issues/397
     {
       code: `
@@ -143,99 +143,116 @@ type obj = {
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function foo1(...args: any[]) {}`,
+      code: 'function foo1(...args: any[]) {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const bar1 = function (...args: any[]) {}`,
+      code: 'const bar1 = function(...args: any[]) {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const baz1 = (...args: any[]) => {}`,
+      code: 'const baz1 = (...args: any[]) => {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function foo2(...args: readonly any[]) {}`,
+      code: 'function foo2(...args: readonly any[]) {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const bar2 = function (...args: readonly any[]) {}`,
+      code: 'const bar2 = function(...args: readonly any[]) {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const baz2 = (...args: readonly any[]) => {}`,
+      code: 'const baz2 = (...args: readonly any[]) => {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function foo3(...args: Array<any>) {}`,
+      code: 'function foo3(...args: Array<any>) {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const bar3 = function (...args: Array<any>) {}`,
+      code: 'const bar3 = function(...args: Array<any>) {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const baz3 = (...args: Array<any>) => {}`,
+      code: 'const baz3 = (...args: Array<any>) => {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function foo4(...args: ReadonlyArray<any>) {}`,
+      code: 'function foo4(...args: ReadonlyArray<any>) {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const bar4 = function (...args: ReadonlyArray<any>) {}`,
+      code: 'const bar4 = function(...args: ReadonlyArray<any>) {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `const baz4 = (...args: ReadonlyArray<any>) => {}`,
+      code: 'const baz4 = (...args: ReadonlyArray<any>) => {};',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `interface Qux1 { (...args: any[]): void; }`,
+      code: `
+interface Qux1 {
+  (...args: any[]): void;
+}
+      `,
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `interface Qux2 { (...args: readonly any[]): void; }`,
+      code: `
+interface Qux2 {
+  (...args: readonly any[]): void;
+}
+      `,
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `interface Qux3 { (...args: Array<any>): void; }`,
+      code: `
+interface Qux3 {
+  (...args: Array<any>): void;
+}
+      `,
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `interface Qux4 { (...args: ReadonlyArray<any>): void; }`,
+      code: `
+interface Qux4 {
+  (...args: ReadonlyArray<any>): void;
+}
+      `,
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quux1(fn: (...args: any[]) => void): void {}`,
+      code: 'function quux1(fn: (...args: any[]) => void): void {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quux2(fn: (...args: readonly any[]) => void): void {}`,
+      code: 'function quux2(fn: (...args: readonly any[]) => void): void {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quux3(fn: (...args: Array<any>) => void): void {}`,
+      code: 'function quux3(fn: (...args: Array<any>) => void): void {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}`,
+      code:
+        'function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quuz1(): ((...args: any[]) => void) {}`,
+      code: 'function quuz1(): (...args: any[]) => void {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quuz2(): ((...args: readonly any[]) => void) {}`,
+      code: 'function quuz2(): (...args: readonly any[]) => void {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quuz3(): ((...args: Array<any>) => void) {}`,
+      code: 'function quuz3(): (...args: Array<any>) => void {}',
       options: [{ ignoreRestArgs: true }],
     },
     {
-      code: `function quuz4(): ((...args: ReadonlyArray<any>) => void) {}`,
+      code: 'function quuz4(): (...args: ReadonlyArray<any>) => void {}',
       options: [{ ignoreRestArgs: true }],
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/no-extra-non-null-assertion.test.ts b/packages/eslint-plugin/tests/rules/no-extra-non-null-assertion.test.ts
index 51ff2d2e43f..02da29353bf 100644
--- a/packages/eslint-plugin/tests/rules/no-extra-non-null-assertion.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-extra-non-null-assertion.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/no-extra-non-null-assertion';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -17,7 +17,8 @@ const bar = foo!.bar;
       code: `
 function foo(bar: number | undefined) {
   const bar: number = bar!;
-}      `,
+}
+      `,
     },
     {
       code: `
@@ -108,11 +109,11 @@ function foo(bar?: { n: number }) {
     },
     // parentheses
     {
-      code: `
+      code: noFormat`
 const foo: { bar: number } | null = null;
 const bar = (foo!)!.bar;
       `,
-      output: `
+      output: noFormat`
 const foo: { bar: number } | null = null;
 const bar = (foo)!.bar;
       `,
@@ -126,12 +127,12 @@ const bar = (foo)!.bar;
       ],
     },
     {
-      code: `
+      code: noFormat`
 function foo(bar?: { n: number }) {
   return (bar!)?.n;
 }
       `,
-      output: `
+      output: noFormat`
 function foo(bar?: { n: number }) {
   return (bar)?.n;
 }
@@ -146,12 +147,12 @@ function foo(bar?: { n: number }) {
       ],
     },
     {
-      code: `
+      code: noFormat`
 function foo(bar?: { n: number }) {
   return (bar)!?.n;
 }
       `,
-      output: `
+      output: noFormat`
 function foo(bar?: { n: number }) {
   return (bar)?.n;
 }
@@ -166,12 +167,12 @@ function foo(bar?: { n: number }) {
       ],
     },
     {
-      code: `
+      code: noFormat`
 function foo(bar?: { n: number }) {
   return (bar!)?.();
 }
       `,
-      output: `
+      output: noFormat`
 function foo(bar?: { n: number }) {
   return (bar)?.();
 }
diff --git a/packages/eslint-plugin/tests/rules/no-extra-parens.test.ts b/packages/eslint-plugin/tests/rules/no-extra-parens.test.ts
index 29afab88ec5..03414b9bc49 100644
--- a/packages/eslint-plugin/tests/rules/no-extra-parens.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-extra-parens.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests extra parens, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import rule from '../../src/rules/no-extra-parens';
 import { RuleTester, batchedSingleLineTests } from '../RuleTester';
 
@@ -49,11 +54,11 @@ for (;(a = b););
       options: ['all', { returnAssign: false }],
     },
     {
-      code: `b => (b = 1);`,
+      code: 'b => (b = 1);',
       options: ['all', { returnAssign: false }],
     },
     {
-      code: `b => b ? (c = d) : (c = e);`,
+      code: 'b => b ? (c = d) : (c = e);',
       options: ['all', { returnAssign: false }],
     },
     ...batchedSingleLineTests({
diff --git a/packages/eslint-plugin/tests/rules/no-extra-semi.test.ts b/packages/eslint-plugin/tests/rules/no-extra-semi.test.ts
index c1e07c18681..db3ca173532 100644
--- a/packages/eslint-plugin/tests/rules/no-extra-semi.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-extra-semi.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests semis, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import rule from '../../src/rules/no-extra-semi';
 import { RuleTester } from '../RuleTester';
 
diff --git a/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts b/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
index 88d558e711a..2bb96f196ef 100644
--- a/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-extraneous-class.test.ts
@@ -20,26 +20,24 @@ ruleTester.run('no-extraneous-class', rule, {
   valid: [
     `
 class Foo {
-    public prop = 1;
-    constructor() {}
+  public prop = 1;
+  constructor() {}
 }
-`,
+    `,
     `
 export class CClass extends BaseClass {
-    public static helper(): void {}
-    private static privateHelper(): boolean {
-        return true;
-    }
-    constructor() {}
+  public static helper(): void {}
+  private static privateHelper(): boolean {
+    return true;
+  }
+  constructor() {}
 }
-`,
+    `,
     `
 class Foo {
-   constructor(
-     public bar: string
-   ) {}
+  constructor(public bar: string) {}
 }
-`,
+    `,
     {
       code: 'class Foo {}',
       options: [{ allowEmpty: true }],
@@ -47,24 +45,30 @@ class Foo {
     {
       code: `
 class Foo {
-    constructor() {}
+  constructor() {}
 }
-`,
+      `,
       options: [{ allowConstructorOnly: true }],
     },
     {
       code: `
 export class Bar {
-    public static helper(): void {}
-    private static privateHelper(): boolean {
-        return true;
-    }
+  public static helper(): void {}
+  private static privateHelper(): boolean {
+    return true;
+  }
 }
-`,
+      `,
       options: [{ allowStaticOnly: true }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/170
-    'export default class { hello() { return "I am foo!"; } }',
+    `
+export default class {
+  hello() {
+    return 'I am foo!';
+  }
+}
+    `,
     {
       code: `
 @FooDecorator
@@ -82,49 +86,51 @@ class Foo {}
     {
       code: `
 class Foo {
-    public prop = 1;
-    constructor() {
-        class Bar {
-            static PROP = 2;
-        }
+  public prop = 1;
+  constructor() {
+    class Bar {
+      static PROP = 2;
     }
+  }
 }
 export class Bar {
-    public static helper(): void {}
-    private static privateHelper(): boolean {
-        return true;
-    }
+  public static helper(): void {}
+  private static privateHelper(): boolean {
+    return true;
+  }
 }
-`,
+      `,
       errors: [onlyStatic, onlyStatic],
     },
     {
       code: `
 class Foo {
-    constructor() {}
+  constructor() {}
 }
-`,
+      `,
       errors: [onlyConstructor],
     },
     {
       code: `
 export class AClass {
-    public static helper(): void {}
-    private static privateHelper(): boolean {
-        return true;
-    }
-    constructor() {
-        class nestedClass {
-        }
-    }
+  public static helper(): void {}
+  private static privateHelper(): boolean {
+    return true;
+  }
+  constructor() {
+    class nestedClass {}
+  }
 }
-
-`,
+      `,
       errors: [onlyStatic, empty],
     },
     {
       // https://github.com/typescript-eslint/typescript-eslint/issues/170
-      code: 'export default class { static hello() {} }',
+      code: `
+export default class {
+  static hello() {}
+}
+      `,
       errors: [
         {
           ...onlyStatic,
diff --git a/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts b/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
index efdbf5e1a48..c7e688c9852 100644
--- a/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-floating-promises.test.ts
@@ -16,57 +16,89 @@ ruleTester.run('no-floating-promises', rule, {
   valid: [
     `
 async function test() {
-  await Promise.resolve("value");
-  Promise.resolve("value").then(() => {}, () => {});
-  Promise.resolve("value").then(() => {}).catch(() => {});
-  Promise.resolve("value").then(() => {}).catch(() => {}).finally(() => {});
-  Promise.resolve("value").catch(() => {});
-  Promise.resolve("value").finally(() => {});
-  return Promise.resolve("value");
-}
-`,
+  await Promise.resolve('value');
+  Promise.resolve('value').then(
+    () => {},
+    () => {},
+  );
+  Promise.resolve('value')
+    .then(() => {})
+    .catch(() => {});
+  Promise.resolve('value')
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  Promise.resolve('value').catch(() => {});
+  Promise.resolve('value').finally(() => {});
+  return Promise.resolve('value');
+}
+    `,
     {
       options: [{ ignoreVoid: true }],
       code: `
 async function test() {
-  void Promise.resolve("value");
+  void Promise.resolve('value');
 }
-`,
+      `,
     },
     `
 async function test() {
-  await Promise.reject(new Error("message"));
-  Promise.reject(new Error("message")).then(() => {}, () => {});
-  Promise.reject(new Error("message")).then(() => {}).catch(() => {});
-  Promise.reject(new Error("message")).then(() => {}).catch(() => {}).finally(() => {});
-  Promise.reject(new Error("message")).catch(() => {});
-  Promise.reject(new Error("message")).finally(() => {});
-  return Promise.reject(new Error("message"));
-}
-`,
+  await Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(
+    () => {},
+    () => {},
+  );
+  Promise.reject(new Error('message'))
+    .then(() => {})
+    .catch(() => {});
+  Promise.reject(new Error('message'))
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
+  Promise.reject(new Error('message')).catch(() => {});
+  Promise.reject(new Error('message')).finally(() => {});
+  return Promise.reject(new Error('message'));
+}
+    `,
     `
 async function test() {
   await (async () => true)();
-  (async () => true)().then(() => {}, () => {});
-  (async () => true)().then(() => {}).catch(() => {});
-  (async () => true)().then(() => {}).catch(() => {}).finally(() => {});
+  (async () => true)().then(
+    () => {},
+    () => {},
+  );
+  (async () => true)()
+    .then(() => {})
+    .catch(() => {});
+  (async () => true)()
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
   (async () => true)().catch(() => {});
   (async () => true)().finally(() => {});
   return (async () => true)();
 }
-`,
+    `,
     `
 async function test() {
   async function returnsPromise() {}
   await returnsPromise();
-  returnsPromise().then(() => {}, () => {});
-  returnsPromise().then(() => {}).catch(() => {});
-  returnsPromise().then(() => {}).catch(() => {}).finally(() => {});
+  returnsPromise().then(
+    () => {},
+    () => {},
+  );
+  returnsPromise()
+    .then(() => {})
+    .catch(() => {});
+  returnsPromise()
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
   returnsPromise().catch(() => {});
   returnsPromise().finally(() => {});
   return returnsPromise();
 }
-`,
+    `,
     `
 async function test() {
   const x = Promise.resolve();
@@ -74,83 +106,120 @@ async function test() {
   y.catch(() => {});
   y.finally(() => {});
 }
-`,
+    `,
     `
 async function test() {
   Math.random() > 0.5 ? Promise.resolve().catch(() => {}) : null;
 }
-`,
+    `,
     `
 async function test() {
   Promise.resolve().catch(() => {}), 123;
   Promise.resolve().finally(() => {}), 123;
-  123, Promise.resolve().then(() => {}, () => {});
-  123, Promise.resolve().then(() => {}, () => {}), 123;
-}
-`,
+  123,
+    Promise.resolve().then(
+      () => {},
+      () => {},
+    );
+  123,
+    Promise.resolve().then(
+      () => {},
+      () => {},
+    ),
+    123;
+}
+    `,
     `
 async function test() {
   void Promise.resolve().catch(() => {});
 }
-`,
+    `,
     `
 async function test() {
-  Promise.resolve().catch(() => {}) || Promise.resolve().then(() => {}, () => {});
+  Promise.resolve().catch(() => {}) ||
+    Promise.resolve().then(
+      () => {},
+      () => {},
+    );
 }
-`,
+    `,
     `
 async function test() {
   const promiseValue: Promise<number>;
 
   await promiseValue;
-  promiseValue.then(() => {}, () => {});
+  promiseValue.then(
+    () => {},
+    () => {},
+  );
   promiseValue.then(() => {}).catch(() => {});
-  promiseValue.then(() => {}).catch(() => {}).finally(() => {});
+  promiseValue
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
   promiseValue.catch(() => {});
   promiseValue.finally(() => {});
   return promiseValue;
 }
-`,
+    `,
     `
 async function test() {
   const promiseUnion: Promise<number> | number;
 
   await promiseUnion;
-  promiseUnion.then(() => {}, () => {});
+  promiseUnion.then(
+    () => {},
+    () => {},
+  );
   promiseUnion.then(() => {}).catch(() => {});
-  promiseUnion.then(() => {}).catch(() => {}).finally(() => {});
+  promiseUnion
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
   promiseUnion.catch(() => {});
   promiseValue.finally(() => {});
   return promiseUnion;
 }
-`,
+    `,
     `
 async function test() {
   const promiseIntersection: Promise<number> & number;
 
   await promiseIntersection;
-  promiseIntersection.then(() => {}, () => {});
+  promiseIntersection.then(
+    () => {},
+    () => {},
+  );
   promiseIntersection.then(() => {}).catch(() => {});
-  promiseIntersection.then(() => {}).catch(() => {}).finally(() => {});
+  promiseIntersection
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
   promiseIntersection.catch(() => {});
   promiseIntersection.finally(() => {});
   return promiseIntersection;
 }
-`,
+    `,
     `
 async function test() {
   class CanThen extends Promise<number> {}
   const canThen: CanThen = Foo.resolve(2);
 
   await canThen;
-  canThen.then(() => {}, () => {});
+  canThen.then(
+    () => {},
+    () => {},
+  );
   canThen.then(() => {}).catch(() => {});
-  canThen.then(() => {}).catch(() => {}).finally(() => {});
+  canThen
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
   canThen.catch(() => {});
   canThen.finally(() => {});
   return canThen;
 }
-`,
+    `,
     `
 async function test() {
   await (Math.random() > 0.5 ? numberPromise : 0);
@@ -160,12 +229,14 @@ async function test() {
   const intersectionPromise: Promise<number> & number;
   await intersectionPromise;
 }
-`,
+    `,
     `
 async function test() {
   class Thenable {
-    then(callback: () => {}): Thenable { return new Thenable(); }
-  };
+    then(callback: () => {}): Thenable {
+      return new Thenable();
+    }
+  }
   const thenable = new Thenable();
 
   await thenable;
@@ -173,14 +244,14 @@ async function test() {
   thenable.then(() => {});
   return thenable;
 }
-`,
+    `,
     `
 async function test() {
   class NonFunctionParamThenable {
     then(param: string, param2: number): NonFunctionParamThenable {
       return new NonFunctionParamThenable();
     }
-  };
+  }
   const thenable = new NonFunctionParamThenable();
 
   await thenable;
@@ -188,30 +259,32 @@ async function test() {
   thenable.then('abc', 'def');
   return thenable;
 }
-`,
+    `,
     `
 async function test() {
-  class NonFunctionThenable { then: number };
+  class NonFunctionThenable {
+    then: number;
+  }
   const thenable = new NonFunctionThenable();
 
   thenable;
   thenable.then;
   return thenable;
 }
-`,
+    `,
     `
 async function test() {
   class CatchableThenable {
     then(callback: () => {}, callback: () => {}): CatchableThenable {
       return new CatchableThenable();
     }
-  };
+  }
   const thenable = new CatchableThenable();
 
-  await thenable
+  await thenable;
   return thenable;
 }
-`,
+    `,
     `
 // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/promise-polyfill/index.d.ts
 // Type definitions for promise-polyfill 6.0
@@ -221,7 +294,7 @@ async function test() {
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 interface PromisePolyfillConstructor extends PromiseConstructor {
-    _immediateFn?: (handler: (() => void) | string) => void;
+  _immediateFn?: (handler: (() => void) | string) => void;
 }
 
 declare const PromisePolyfill: PromisePolyfillConstructor;
@@ -230,39 +303,50 @@ async function test() {
   const promise = new PromisePolyfill(() => {});
 
   await promise;
-  promise.then(() => {}, () => {});
+  promise.then(
+    () => {},
+    () => {},
+  );
   promise.then(() => {}).catch(() => {});
-  promise.then(() => {}).catch(() => {}).finally(() => {});
+  promise
+    .then(() => {})
+    .catch(() => {})
+    .finally(() => {});
   promise.catch(() => {});
   promise.finally(() => {});
   return promise;
 }
-`,
+    `,
 
     // optional chaining
     `
 async function test() {
   declare const returnsPromise: () => Promise<void> | null;
   await returnsPromise?.();
-  returnsPromise()?.then(() => {}, () => {});
-  returnsPromise()?.then(() => {})?.catch(() => {});
+  returnsPromise()?.then(
+    () => {},
+    () => {},
+  );
+  returnsPromise()
+    ?.then(() => {})
+    ?.catch(() => {});
   returnsPromise()?.catch(() => {});
   returnsPromise()?.finally(() => {});
   return returnsPromise();
 }
-  `,
+    `,
   ],
 
   invalid: [
     {
       code: `
 async function test() {
-  Promise.resolve("value");
-  Promise.resolve("value").then(() => {});
-  Promise.resolve("value").catch();
-  Promise.resolve("value").finally();
+  Promise.resolve('value');
+  Promise.resolve('value').then(() => {});
+  Promise.resolve('value').catch();
+  Promise.resolve('value').finally();
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -286,9 +370,9 @@ async function test() {
       options: [{ ignoreVoid: true }],
       code: `
 async function test() {
-  Promise.resolve("value");
+  Promise.resolve('value');
 }
-`,
+      `.trimRight(),
       errors: [
         {
           line: 3,
@@ -298,9 +382,9 @@ async function test() {
               messageId: 'floatingFixVoid',
               output: `
 async function test() {
-  void Promise.resolve("value");
+  void Promise.resolve('value');
 }
-`,
+              `.trimRight(),
             },
           ],
         },
@@ -309,12 +393,12 @@ async function test() {
     {
       code: `
 async function test() {
-  Promise.reject(new Error("message"));
-  Promise.reject(new Error("message")).then(() => {});
-  Promise.reject(new Error("message")).catch();
-  Promise.reject(new Error("message")).finally();
+  Promise.reject(new Error('message'));
+  Promise.reject(new Error('message')).then(() => {});
+  Promise.reject(new Error('message')).catch();
+  Promise.reject(new Error('message')).finally();
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -342,7 +426,7 @@ async function test() {
   (async () => true)().catch();
   (async () => true)().finally();
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -372,7 +456,7 @@ async function test() {
   returnsPromise().catch();
   returnsPromise().finally();
 }
-`,
+      `,
       errors: [
         {
           line: 5,
@@ -398,7 +482,7 @@ async function test() {
   Math.random() > 0.5 ? Promise.resolve() : null;
   Math.random() > 0.5 ? null : Promise.resolve();
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -413,11 +497,11 @@ async function test() {
     {
       code: `
 async function test() {
-  Promise.resolve(), 123
-  123, Promise.resolve()
-  123, Promise.resolve(), 123
+  Promise.resolve(), 123;
+  123, Promise.resolve();
+  123, Promise.resolve(), 123;
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -438,7 +522,7 @@ async function test() {
 async function test() {
   void Promise.resolve();
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -452,7 +536,7 @@ async function test() {
   const obj = { foo: Promise.resolve() };
   obj.foo;
 }
-`,
+      `,
       errors: [
         {
           line: 4,
@@ -465,7 +549,7 @@ async function test() {
 async function test() {
   new Promise(resolve => resolve());
 }
-`,
+      `,
       errors: [
         {
           line: 3,
@@ -483,7 +567,7 @@ async function test() {
   promiseValue.catch();
   promiseValue.finally();
 }
-`,
+      `,
       errors: [
         {
           line: 5,
@@ -510,7 +594,7 @@ async function test() {
 
   promiseUnion;
 }
-`,
+      `,
       errors: [
         {
           line: 5,
@@ -524,11 +608,11 @@ async function test() {
   const promiseIntersection: Promise<number> & number;
 
   promiseIntersection;
-  promiseIntersection.then(() => {})
+  promiseIntersection.then(() => {});
   promiseIntersection.catch();
   promiseIntersection.finally();
 }
-`,
+      `,
       errors: [
         {
           line: 5,
@@ -559,7 +643,7 @@ async function test() {
   canThen.catch();
   canThen.finally();
 }
-`,
+      `,
       errors: [
         {
           line: 6,
@@ -586,13 +670,13 @@ async function test() {
     then(callback: () => {}, callback: () => {}): CatchableThenable {
       return new CatchableThenable();
     }
-  };
+  }
   const thenable = new CatchableThenable();
 
   thenable;
   thenable.then(() => {});
 }
-`,
+      `,
       errors: [
         {
           line: 10,
@@ -614,7 +698,7 @@ async function test() {
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 interface PromisePolyfillConstructor extends PromiseConstructor {
-    _immediateFn?: (handler: (() => void) | string) => void;
+  _immediateFn?: (handler: (() => void) | string) => void;
 }
 
 declare const PromisePolyfill: PromisePolyfillConstructor;
@@ -626,7 +710,7 @@ async function test() {
   promise.then(() => {});
   promise.catch();
 }
-`,
+      `,
       errors: [
         {
           line: 18,
diff --git a/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts b/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts
index 44a40942c9f..134fd513e87 100644
--- a/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-for-in-array.test.ts
@@ -16,20 +16,23 @@ ruleTester.run('no-for-in-array', rule, {
   valid: [
     `
 for (const x of [3, 4, 5]) {
-    console.log(x);
-}`,
+  console.log(x);
+}
+    `,
     `
 for (const x in { a: 1, b: 2, c: 3 }) {
-    console.log(x);
-}`,
+  console.log(x);
+}
+    `,
   ],
 
   invalid: [
     {
       code: `
 for (const x in [3, 4, 5]) {
-    console.log(x);
-}`,
+  console.log(x);
+}
+      `,
       errors: [
         {
           messageId: 'forInViolation',
@@ -41,8 +44,9 @@ for (const x in [3, 4, 5]) {
       code: `
 const z = [3, 4, 5];
 for (const x in z) {
-    console.log(x);
-}`,
+  console.log(x);
+}
+      `,
       errors: [
         {
           messageId: 'forInViolation',
diff --git a/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts b/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
index b92b61eff6a..521f838f06f 100644
--- a/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-implied-eval.test.ts
@@ -13,28 +13,28 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-implied-eval', rule, {
   valid: [
-    `foo.setImmediate(null);`,
-    `foo.setInterval(null);`,
-    `foo.execScript(null);`,
-    `foo.setTimeout(null);`,
-    `foo()`,
-    `(function(){ })()`,
+    'foo.setImmediate(null);',
+    'foo.setInterval(null);',
+    'foo.execScript(null);',
+    'foo.setTimeout(null);',
+    'foo();',
+    '(function() {})();',
 
-    `setTimeout(() => {}, 0);`,
-    `window.setTimeout(() => {}, 0);`,
-    `window['setTimeout'](() => {}, 0);`,
+    'setTimeout(() => {}, 0);',
+    'window.setTimeout(() => {}, 0);',
+    "window['setTimeout'](() => {}, 0);",
 
-    `setInterval(() => {}, 0);`,
-    `window.setInterval(() => {}, 0);`,
-    `window['setInterval'](() => {}, 0);`,
+    'setInterval(() => {}, 0);',
+    'window.setInterval(() => {}, 0);',
+    "window['setInterval'](() => {}, 0);",
 
-    `setImmediate(() => {});`,
-    `window.setImmediate(() => {});`,
-    `window['setImmediate'](() => {});`,
+    'setImmediate(() => {});',
+    'window.setImmediate(() => {});',
+    "window['setImmediate'](() => {});",
 
-    `execScript(() => {});`,
-    `window.execScript(() => {});`,
-    `window['execScript'](() => {});`,
+    'execScript(() => {});',
+    'window.execScript(() => {});',
+    "window['execScript'](() => {});",
 
     `
 const foo = () => {};
@@ -45,7 +45,7 @@ setImmediate(foo);
 execScript(foo);
     `,
     `
-const foo = function () {};
+const foo = function() {};
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
@@ -53,7 +53,7 @@ setImmediate(foo);
 execScript(foo);
     `,
     `
-function foo() {};
+function foo() {}
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
@@ -63,7 +63,7 @@ execScript(foo);
     `
 const foo = {
   fn: () => {},
-}
+};
 
 setTimeout(foo.fn, 0);
 setInterval(foo.fn, 0);
@@ -72,8 +72,8 @@ execScript(foo.fn);
     `,
     `
 const foo = {
-  fn: function () {},
-}
+  fn: function() {},
+};
 
 setTimeout(foo.fn, 0);
 setInterval(foo.fn, 0);
@@ -83,7 +83,7 @@ execScript(foo.fn);
     `
 const foo = {
   fn: function foo() {},
-}
+};
 
 setTimeout(foo.fn, 0);
 setInterval(foo.fn, 0);
@@ -93,7 +93,7 @@ execScript(foo.fn);
     `
 const foo = {
   fn() {},
-}
+};
 
 setTimeout(foo.fn, 0);
 setInterval(foo.fn, 0);
@@ -103,7 +103,7 @@ execScript(foo.fn);
     `
 const foo = {
   fn: () => {},
-}
+};
 const fn = 'fn';
 
 setTimeout(foo[fn], 0);
@@ -114,7 +114,7 @@ execScript(foo[fn]);
     `
 const foo = {
   fn: () => {},
-}
+};
 
 setTimeout(foo['fn'], 0);
 setInterval(foo['fn'], 0);
@@ -122,8 +122,7 @@ setImmediate(foo['fn']);
 execScript(foo['fn']);
     `,
     `
-const foo: () => void = () => {
-};
+const foo: () => void = () => {};
 
 setTimeout(foo, 0);
 setInterval(foo, 0);
@@ -131,9 +130,9 @@ setImmediate(foo);
 execScript(foo);
     `,
     `
-const foo: (() => () => void) = () => {
+const foo: () => () => void = () => {
   return () => {};
-}
+};
 
 setTimeout(foo(), 0);
 setInterval(foo(), 0);
@@ -141,7 +140,7 @@ setImmediate(foo());
 execScript(foo());
     `,
     `
-const foo: (() => () => void) = () => () => {};
+const foo: () => () => void = () => () => {};
 
 setTimeout(foo(), 0);
 setInterval(foo(), 0);
@@ -157,9 +156,9 @@ setImmediate(foo());
 execScript(foo());
     `,
     `
-const foo = function foo () {
-  return function foo() {}
-}
+const foo = function foo() {
+  return function foo() {};
+};
 
 setTimeout(foo(), 0);
 setInterval(foo(), 0);
@@ -167,11 +166,11 @@ setImmediate(foo());
 execScript(foo());
     `,
     `
-const foo = function () {
-  return function () {
+const foo = function() {
+  return function() {
     return '';
-  }
-}
+  };
+};
 
 setTimeout(foo(), 0);
 setInterval(foo(), 0);
@@ -179,9 +178,9 @@ setImmediate(foo());
 execScript(foo());
     `,
     `
-const foo: (() => () => void) = function foo () {
-  return function foo() {}
-}
+const foo: () => () => void = function foo() {
+  return function foo() {};
+};
 
 setTimeout(foo(), 0);
 setInterval(foo(), 0);
@@ -240,7 +239,7 @@ const fn = (foo: () => void) => {
   setInterval(foo, 0);
   setImmediate(foo);
   execScript(foo);
-}
+};
     `,
   ],
 
@@ -369,7 +368,7 @@ execScript(foo);
     },
     {
       code: `
-const foo = function () {
+const foo = function() {
   return 'x + 1';
 };
 
@@ -403,7 +402,7 @@ execScript(foo());
     },
     {
       code: `
-const foo = function () {
+const foo = function() {
   return () => 'x + 1';
 };
 
@@ -437,7 +436,7 @@ execScript(foo()());
     },
     {
       code: `
-const fn = function () {}
+const fn = function() {};
 
 setTimeout(fn + '', 0);
 setInterval(fn + '', 0);
@@ -570,7 +569,7 @@ const fn = (foo: string | any) => {
   setInterval(foo, 0);
   setImmediate(foo);
   execScript(foo);
-}
+};
       `,
       errors: [
         {
@@ -653,7 +652,7 @@ window['execScript'](\`\`);
       ],
     },
     {
-      code: `const fn = Function()`,
+      code: 'const fn = Function();',
       errors: [
         {
           messageId: 'noFunctionConstructor',
@@ -663,7 +662,7 @@ window['execScript'](\`\`);
       ],
     },
     {
-      code: `const fn = new Function('a', 'b', 'return a + b');`,
+      code: "const fn = new Function('a', 'b', 'return a + b');",
       errors: [
         {
           messageId: 'noFunctionConstructor',
@@ -673,7 +672,7 @@ window['execScript'](\`\`);
       ],
     },
     {
-      code: `const fn = window.Function();`,
+      code: 'const fn = window.Function();',
       errors: [
         {
           messageId: 'noFunctionConstructor',
@@ -683,7 +682,7 @@ window['execScript'](\`\`);
       ],
     },
     {
-      code: `const fn = new window.Function();`,
+      code: 'const fn = new window.Function();',
       errors: [
         {
           messageId: 'noFunctionConstructor',
@@ -693,7 +692,7 @@ window['execScript'](\`\`);
       ],
     },
     {
-      code: `const fn = window['Function']();`,
+      code: "const fn = window['Function']();",
       errors: [
         {
           messageId: 'noFunctionConstructor',
@@ -703,7 +702,7 @@ window['execScript'](\`\`);
       ],
     },
     {
-      code: `const fn = new window['Function']();`,
+      code: "const fn = new window['Function']();",
       errors: [
         {
           messageId: 'noFunctionConstructor',
diff --git a/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts b/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
index 050e7bee416..b87e778d508 100644
--- a/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-inferrable-types.test.ts
@@ -102,20 +102,30 @@ ruleTester.run('no-inferrable-types', rule, {
   valid: [
     ...validTestCases,
 
-    "const fn = (a = 5, b = true, c = 'foo') => {}",
-    "const fn = function(a = 5, b = true, c = 'foo') {}",
+    "const fn = (a = 5, b = true, c = 'foo') => {};",
+    "const fn = function(a = 5, b = true, c = 'foo') {};",
     "function fn(a = 5, b = true, c = 'foo') {}",
     'function fn(a: number, b: boolean, c: string) {}',
 
-    "class Foo { a = 5; b = true; c = 'foo'; }",
-    'class Foo { readonly a: number = 5; }',
+    `
+class Foo {
+  a = 5;
+  b = true;
+  c = 'foo';
+}
+    `,
+    `
+class Foo {
+  readonly a: number = 5;
+}
+    `,
 
-    'const a: any = 5',
-    "const fn = function(a: any = 5, b: any = true, c: any = 'foo') {}",
+    'const a: any = 5;',
+    "const fn = function(a: any = 5, b: any = true, c: any = 'foo') {};",
 
     {
       code:
-        "const fn = (a: number = 5, b: boolean = true, c: string = 'foo') => {}",
+        "const fn = (a: number = 5, b: boolean = true, c: string = 'foo') => {};",
       options: [{ ignoreParameters: true }],
     },
     {
@@ -125,12 +135,17 @@ ruleTester.run('no-inferrable-types', rule, {
     },
     {
       code:
-        "const fn = function(a: number = 5, b: boolean = true, c: string = 'foo') {}",
+        "const fn = function(a: number = 5, b: boolean = true, c: string = 'foo') {};",
       options: [{ ignoreParameters: true }],
     },
     {
-      code:
-        "class Foo { a: number = 5; b: boolean = true; c: string = 'foo'; }",
+      code: `
+class Foo {
+  a: number = 5;
+  b: boolean = true;
+  c: string = 'foo';
+}
+      `,
       options: [{ ignoreProperties: true }],
     },
     {
@@ -149,8 +164,8 @@ class Foo {
 
     {
       code:
-        "const fn = (a: number = 5, b: boolean = true, c: string = 'foo') => {}",
-      output: "const fn = (a = 5, b = true, c = 'foo') => {}",
+        "const fn = (a: number = 5, b: boolean = true, c: string = 'foo') => {};",
+      output: "const fn = (a = 5, b = true, c = 'foo') => {};",
       options: [
         {
           ignoreParameters: false,
@@ -185,9 +200,20 @@ class Foo {
       ],
     },
     {
-      code:
-        "class Foo { a: number = 5; b: boolean = true; c: string = 'foo'; }",
-      output: "class Foo { a = 5; b = true; c = 'foo'; }",
+      code: `
+class Foo {
+  a: number = 5;
+  b: boolean = true;
+  c: string = 'foo';
+}
+      `,
+      output: `
+class Foo {
+  a = 5;
+  b = true;
+  c = 'foo';
+}
+      `,
       options: [
         {
           ignoreParameters: false,
@@ -200,24 +226,24 @@ class Foo {
           data: {
             type: 'number',
           },
-          line: 1,
-          column: 13,
+          line: 3,
+          column: 3,
         },
         {
           messageId: 'noInferrableType',
           data: {
             type: 'boolean',
           },
-          line: 1,
-          column: 28,
+          line: 4,
+          column: 3,
         },
         {
           messageId: 'noInferrableType',
           data: {
             type: 'string',
           },
-          line: 1,
-          column: 47,
+          line: 5,
+          column: 3,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts b/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
index 9c8bdeae10a..0c220805085 100644
--- a/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-magic-numbers.test.ts
@@ -12,7 +12,7 @@ ruleTester.run('no-magic-numbers', rule, {
       options: [{ ignoreNumericLiteralTypes: true }],
     },
     {
-      code: 'type Foo = "bar";',
+      code: "type Foo = 'bar';",
     },
     {
       code: 'type Foo = true;',
@@ -37,7 +37,7 @@ ruleTester.run('no-magic-numbers', rule, {
       code: `
         enum foo {
           SECOND = 1000,
-          NUM = "0123456789",
+          NUM = '0123456789',
           NEG = -1,
           POS = +1,
         }
@@ -141,7 +141,11 @@ class Foo {
       ],
     },
     {
-      code: 'interface Foo { bar: 1; }',
+      code: `
+interface Foo {
+  bar: 1;
+}
+      `,
       options: [{ ignoreNumericLiteralTypes: true }],
       errors: [
         {
@@ -149,8 +153,8 @@ class Foo {
           data: {
             raw: '1',
           },
-          line: 1,
-          column: 22,
+          line: 3,
+          column: 8,
         },
       ],
     },
@@ -158,7 +162,7 @@ class Foo {
       code: `
 enum foo {
   SECOND = 1000,
-  NUM = "0123456789",
+  NUM = '0123456789',
   NEG = -1,
   POS = +1,
 }
diff --git a/packages/eslint-plugin/tests/rules/no-misused-new.test.ts b/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
index 414d86245d5..527d5d46671 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-new.test.ts
@@ -9,46 +9,89 @@ ruleTester.run('no-misused-new', rule, {
   valid: [
     `
 declare abstract class C {
-    foo () {
-    }
-    get new ();
-    bar();
+  foo() {}
+  get new();
+  bar();
 }
     `,
-    'class C { constructor(); }',
-    'const foo = class { constructor(); }',
-    'const foo = class { new(): X }',
+    `
+class C {
+  constructor();
+}
+    `,
+    `
+const foo = class {
+  constructor();
+};
+    `,
+    `
+const foo = class {
+  new(): X;
+};
+    `,
     // OK if there's a body
-    'class C { new() {} }',
-    'class C { constructor() {} }',
-    'const foo = class { new() {} }',
-    'const foo = class { constructor() {} }',
+    `
+class C {
+  new() {}
+}
+    `,
+    `
+class C {
+  constructor() {}
+}
+    `,
+    `
+const foo = class {
+  new() {}
+};
+    `,
+    `
+const foo = class {
+  constructor() {}
+};
+    `,
     // OK if return type is not the interface.
-    'interface I { new(): {}; }',
+    `
+interface I {
+  new (): {};
+}
+    `,
     // 'new' OK in type literal (we don't know the type name)
-    'type T = { new(): T; }',
-    'export default class { constructor(); }',
-    'interface foo { new<T>(): bar<T>; }',
-    "interface foo { new<T>(): 'x'; }",
+    'type T = { new (): T };',
+    `
+export default class {
+  constructor();
+}
+    `,
+    `
+interface foo {
+  new <T>(): bar<T>;
+}
+    `,
+    `
+interface foo {
+  new <T>(): 'x';
+}
+    `,
   ],
   invalid: [
     {
       code: `
 interface I {
-    new(): I;
-    constructor(): void;
+  new (): I;
+  constructor(): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'errorMessageInterface',
           line: 3,
-          column: 5,
+          column: 3,
         },
         {
           messageId: 'errorMessageInterface',
           line: 4,
-          column: 5,
+          column: 3,
         },
       ],
     },
@@ -56,14 +99,14 @@ interface I {
     {
       code: `
 interface G {
-    new<T>(): G<T>;
+  new <T>(): G<T>;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'errorMessageInterface',
           line: 3,
-          column: 5,
+          column: 3,
         },
       ],
     },
@@ -71,56 +114,56 @@ interface G {
     {
       code: `
 type T = {
-    constructor(): void;
-}
-`,
+  constructor(): void;
+};
+      `,
       errors: [
         {
           messageId: 'errorMessageInterface',
           line: 3,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 class C {
-    new(): C;
+  new(): C;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'errorMessageClass',
           line: 3,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 declare abstract class C {
-    new(): C;
+  new(): C;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'errorMessageClass',
           line: 3,
-          column: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 interface I {
-    constructor(): '';
+  constructor(): '';
 }
-`,
+      `,
       errors: [
         {
           messageId: 'errorMessageInterface',
           line: 3,
-          column: 5,
+          column: 3,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts b/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
index fb18a3875e3..cda131067fa 100644
--- a/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-misused-promises.test.ts
@@ -14,66 +14,81 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-misused-promises', rule, {
   valid: [
-    `if (true) {}`,
+    `
+if (true) {
+}
+    `,
     {
-      code: `if (Promise.resolve()) {}`,
+      code: `
+if (Promise.resolve()) {
+}
+      `,
       options: [{ checksConditionals: false }],
     },
     `
-if (true) {}
-else if (false) {}
-else {}
-`,
+if (true) {
+} else if (false) {
+} else {
+}
+    `,
     {
       code: `
-if (Promise.resolve()) {}
-else if (Promise.resolve()) {}
-else {}
-`,
+if (Promise.resolve()) {
+} else if (Promise.resolve()) {
+} else {
+}
+      `,
       options: [{ checksConditionals: false }],
     },
-    `for (;;) {}`,
-    `for (let i; i < 10; i++) {}`,
+    'for (;;) {}',
+    'for (let i; i < 10; i++) {}',
     {
-      code: `for (let i; Promise.resolve(); i++) {}`,
+      code: 'for (let i; Promise.resolve(); i++) {}',
       options: [{ checksConditionals: false }],
     },
-    `do {} while (true);`,
+    'do {} while (true);',
     {
-      code: `do {} while (Promise.resolve())`,
+      code: 'do {} while (Promise.resolve());',
       options: [{ checksConditionals: false }],
     },
-    `while (true) {}`,
+    'while (true) {}',
     {
-      code: `while (Promise.resolve()) {}`,
+      code: 'while (Promise.resolve()) {}',
       options: [{ checksConditionals: false }],
     },
-    `true ? 123 : 456`,
+    'true ? 123 : 456;',
     {
-      code: `Promise.resolve() ? 123 : 456`,
+      code: 'Promise.resolve() ? 123 : 456;',
       options: [{ checksConditionals: false }],
     },
-    `if (!true) {}`,
+    `
+if (!true) {
+}
+    `,
     {
-      code: `if (!Promise.resolve()) {}`,
+      code: `
+if (!Promise.resolve()) {
+}
+      `,
       options: [{ checksConditionals: false }],
     },
-    `(await Promise.resolve()) || false`,
+    '(await Promise.resolve()) || false;',
     {
-      code: `Promise.resolve() || false`,
+      code: 'Promise.resolve() || false;',
       options: [{ checksConditionals: false }],
     },
-    `(true && await Promise.resolve()) || false`,
+    '(true && (await Promise.resolve())) || false;',
     {
-      code: `(true && Promise.resolve()) || false`,
+      code: '(true && Promise.resolve()) || false;',
       options: [{ checksConditionals: false }],
     },
-    `false || (true && Promise.resolve())`,
+    'false || (true && Promise.resolve());',
     `
 async function test() {
-  if (await Promise.resolve()) {}
+  if (await Promise.resolve()) {
+  }
 }
-`,
+    `,
     `
 async function test() {
   const mixed: Promise | undefined = Promise.resolve();
@@ -81,57 +96,73 @@ async function test() {
     await mixed;
   }
 }
-`,
-    `if (~Promise.resolve()) {}`,
+    `,
+    `
+if (~Promise.resolve()) {
+}
+    `,
     `
 interface NotQuiteThenable {
   then(param: string): void;
   then(): void;
 }
 const value: NotQuiteThenable = { then() {} };
-if (value) {}
-`,
-    `[1, 2, 3].forEach(val => {});`,
+if (value) {
+}
+    `,
+    '[1, 2, 3].forEach(val => {});',
     {
-      code: `[1, 2, 3].forEach(async val => {});`,
+      code: '[1, 2, 3].forEach(async val => {});',
       options: [{ checksVoidReturn: false }],
     },
-    `new Promise((resolve, reject) => resolve());`,
+    'new Promise((resolve, reject) => resolve());',
     {
-      code: `new Promise(async (resolve, reject) => resolve());`,
+      code: 'new Promise(async (resolve, reject) => resolve());',
       options: [{ checksVoidReturn: false }],
     },
-    `Promise.all(['abc', 'def'].map(async val => { await val; }))`,
+    `
+Promise.all(
+  ['abc', 'def'].map(async val => {
+    await val;
+  }),
+);
+    `,
     `
 const fn: (arg: () => Promise<void> | void) => void = () => {};
 fn(() => Promise.resolve());
     `,
     `
-declare const returnsPromise : (() => Promise<void>) | null;
-if (returnsPromise?.()) {}
+declare const returnsPromise: (() => Promise<void>) | null;
+if (returnsPromise?.()) {
+}
     `,
     `
-declare const returnsPromise : { call: (() => Promise<void>) } | null;
-if (returnsPromise?.call()) {}
+declare const returnsPromise: { call: () => Promise<void> } | null;
+if (returnsPromise?.call()) {
+}
     `,
   ],
 
   invalid: [
     {
-      code: `if (Promise.resolve()) {}`,
+      code: `
+if (Promise.resolve()) {
+}
+      `,
       errors: [
         {
-          line: 1,
+          line: 2,
           messageId: 'conditional',
         },
       ],
     },
     {
       code: `
-if (Promise.resolve()) {}
-else if (Promise.resolve()) {}
-else {}
-`,
+if (Promise.resolve()) {
+} else if (Promise.resolve()) {
+} else {
+}
+      `,
       errors: [
         {
           line: 2,
@@ -144,7 +175,7 @@ else {}
       ],
     },
     {
-      code: `for (let i; Promise.resolve(); i++) {}`,
+      code: 'for (let i; Promise.resolve(); i++) {}',
       errors: [
         {
           line: 1,
@@ -153,7 +184,7 @@ else {}
       ],
     },
     {
-      code: `do {} while (Promise.resolve())`,
+      code: 'do {} while (Promise.resolve());',
       errors: [
         {
           line: 1,
@@ -162,7 +193,7 @@ else {}
       ],
     },
     {
-      code: `while (Promise.resolve()) {}`,
+      code: 'while (Promise.resolve()) {}',
       errors: [
         {
           line: 1,
@@ -171,7 +202,7 @@ else {}
       ],
     },
     {
-      code: `Promise.resolve() ? 123 : 456`,
+      code: 'Promise.resolve() ? 123 : 456;',
       errors: [
         {
           line: 1,
@@ -180,16 +211,19 @@ else {}
       ],
     },
     {
-      code: `if (!Promise.resolve()) {}`,
+      code: `
+if (!Promise.resolve()) {
+}
+      `,
       errors: [
         {
-          line: 1,
+          line: 2,
           messageId: 'conditional',
         },
       ],
     },
     {
-      code: `Promise.resolve() || false`,
+      code: 'Promise.resolve() || false;',
       errors: [
         {
           line: 1,
@@ -198,7 +232,7 @@ else {}
       ],
     },
     {
-      code: `(true && Promise.resolve()) || false`,
+      code: '(true && Promise.resolve()) || false;',
       errors: [
         {
           line: 1,
@@ -208,13 +242,13 @@ else {}
     },
     {
       code: `
-[Promise.resolve(), Promise.reject()].forEach(
-  async val => { await val; }
-);
-`,
+[Promise.resolve(), Promise.reject()].forEach(async val => {
+  await val;
+});
+      `,
       errors: [
         {
-          line: 3,
+          line: 2,
           messageId: 'voidReturn',
         },
       ],
@@ -225,7 +259,7 @@ new Promise(async (resolve, reject) => {
   await Promise.resolve();
   resolve();
 });
-`,
+      `,
       errors: [
         {
           line: 2,
@@ -242,7 +276,7 @@ const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
 fnWithCallback('val', async (err, res) => {
   await res;
 });
-`,
+      `,
       errors: [
         {
           line: 6,
@@ -257,7 +291,7 @@ const fnWithCallback = (arg: string, cb: (err: any, res: string) => void) => {
 };
 
 fnWithCallback('val', (err, res) => Promise.resolve(res));
-`,
+      `,
       errors: [
         {
           line: 6,
@@ -278,7 +312,7 @@ fnWithCallback('val', (err, res) => {
     return Promise.resolve(res);
   }
 });
-`,
+      `,
       errors: [
         {
           line: 6,
@@ -288,22 +322,26 @@ fnWithCallback('val', (err, res) => {
     },
     {
       code: `
-const fnWithCallback: ((arg: string, cb: (err: any, res: string) => void) => void) | null = (arg, cb) => {
+const fnWithCallback:
+  | ((arg: string, cb: (err: any, res: string) => void) => void)
+  | null = (arg, cb) => {
   cb(null, arg);
 };
 
 fnWithCallback?.('val', (err, res) => Promise.resolve(res));
-`,
+      `,
       errors: [
         {
-          line: 6,
+          line: 8,
           messageId: 'voidReturn',
         },
       ],
     },
     {
       code: `
-const fnWithCallback: ((arg: string, cb: (err: any, res: string) => void) => void) | null = (arg, cb) => {
+const fnWithCallback:
+  | ((arg: string, cb: (err: any, res: string) => void) => void)
+  | null = (arg, cb) => {
   cb(null, arg);
 };
 
@@ -314,10 +352,10 @@ fnWithCallback('val', (err, res) => {
     return Promise.resolve(res);
   }
 });
-`,
+      `,
       errors: [
         {
-          line: 6,
+          line: 8,
           messageId: 'voidReturn',
         },
       ],
diff --git a/packages/eslint-plugin/tests/rules/no-namespace.test.ts b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
index 1b9cade4cc6..e175f5895df 100644
--- a/packages/eslint-plugin/tests/rules/no-namespace.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-namespace.test.ts
@@ -7,24 +7,24 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-namespace', rule, {
   valid: [
-    'declare global { }',
-    "declare module 'foo' { }",
+    'declare global {}',
+    "declare module 'foo' {}",
     {
-      code: 'declare module foo { }',
+      code: 'declare module foo {}',
       options: [{ allowDeclarations: true }],
     },
     {
-      code: 'declare namespace foo { }',
+      code: 'declare namespace foo {}',
       options: [{ allowDeclarations: true }],
     },
     {
       filename: 'test.d.ts',
-      code: 'namespace foo { }',
+      code: 'namespace foo {}',
       options: [{ allowDefinitionFiles: true }],
     },
     {
       filename: 'test.d.ts',
-      code: 'module foo { }',
+      code: 'module foo {}',
       options: [{ allowDefinitionFiles: true }],
     },
   ],
@@ -72,7 +72,7 @@ ruleTester.run('no-namespace', rule, {
       ],
     },
     {
-      code: 'declare module foo { }',
+      code: 'declare module foo {}',
       errors: [
         {
           messageId: 'moduleSyntaxIsPreferred',
@@ -82,7 +82,7 @@ ruleTester.run('no-namespace', rule, {
       ],
     },
     {
-      code: 'declare namespace foo { }',
+      code: 'declare namespace foo {}',
       errors: [
         {
           messageId: 'moduleSyntaxIsPreferred',
@@ -115,7 +115,7 @@ ruleTester.run('no-namespace', rule, {
     },
     {
       filename: 'test.d.ts',
-      code: 'namespace foo { }',
+      code: 'namespace foo {}',
       options: [{ allowDefinitionFiles: false }],
       errors: [
         {
@@ -127,7 +127,7 @@ ruleTester.run('no-namespace', rule, {
     },
     {
       filename: 'test.d.ts',
-      code: 'module foo { }',
+      code: 'module foo {}',
       options: [{ allowDefinitionFiles: false }],
       errors: [
         {
@@ -179,7 +179,7 @@ namespace Foo.Bar {
     interface X {}
   }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'moduleSyntaxIsPreferred',
diff --git a/packages/eslint-plugin/tests/rules/no-non-null-asserted-optional-chain.test.ts b/packages/eslint-plugin/tests/rules/no-non-null-asserted-optional-chain.test.ts
index 33e95fa91a9..0a28cbbfc92 100644
--- a/packages/eslint-plugin/tests/rules/no-non-null-asserted-optional-chain.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-non-null-asserted-optional-chain.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/no-non-null-asserted-optional-chain';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -7,177 +7,177 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-non-null-asserted-optional-chain', rule, {
   valid: [
-    'foo.bar!',
-    'foo.bar()!',
-    'foo?.bar',
-    'foo?.bar()',
-    '(foo?.bar).baz!',
-    '(foo?.bar()).baz!',
+    'foo.bar!;',
+    'foo.bar()!;',
+    'foo?.bar;',
+    'foo?.bar();',
+    '(foo?.bar).baz!;',
+    '(foo?.bar()).baz!;',
   ],
   invalid: [
     {
-      code: 'foo?.bar!',
+      code: 'foo?.bar!;',
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: 'foo?.bar',
+              output: 'foo?.bar;',
             },
           ],
         },
       ],
     },
     {
-      code: 'foo?.["bar"]!',
+      code: "foo?.['bar']!;",
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: 'foo?.["bar"]',
+              output: "foo?.['bar'];",
             },
           ],
         },
       ],
     },
     {
-      code: 'foo?.bar()!',
+      code: 'foo?.bar()!;',
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: 'foo?.bar()',
+              output: 'foo?.bar();',
             },
           ],
         },
       ],
     },
     {
-      code: 'foo.bar?.()!',
+      code: 'foo.bar?.()!;',
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: 'foo.bar?.()',
+              output: 'foo.bar?.();',
             },
           ],
         },
       ],
     },
     {
-      code: 'foo?.bar!()',
+      code: 'foo?.bar!();',
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: 'foo?.bar()',
+              output: 'foo?.bar();',
             },
           ],
         },
       ],
     },
     {
-      code: '(foo?.bar)!.baz',
+      code: noFormat`(foo?.bar)!.baz`,
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: '(foo?.bar).baz',
+              output: noFormat`(foo?.bar).baz`,
             },
           ],
         },
       ],
     },
     {
-      code: 'foo?.["bar"]!.baz',
+      code: "foo?.['bar']!.baz;",
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: 'foo?.["bar"].baz',
+              output: "foo?.['bar'].baz;",
             },
           ],
         },
       ],
     },
     {
-      code: '(foo?.bar)!().baz',
+      code: noFormat`(foo?.bar)!().baz`,
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: '(foo?.bar)().baz',
+              output: noFormat`(foo?.bar)().baz`,
             },
           ],
         },
       ],
     },
     {
-      code: '(foo?.bar)!',
+      code: noFormat`(foo?.bar)!`,
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: '(foo?.bar)',
+              output: noFormat`(foo?.bar)`,
             },
           ],
         },
       ],
     },
     {
-      code: '(foo?.bar)!()',
+      code: noFormat`(foo?.bar)!()`,
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: '(foo?.bar)()',
+              output: noFormat`(foo?.bar)()`,
             },
           ],
         },
       ],
     },
     {
-      code: '(foo?.bar!)',
+      code: noFormat`(foo?.bar!)`,
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: '(foo?.bar)',
+              output: noFormat`(foo?.bar)`,
             },
           ],
         },
       ],
     },
     {
-      code: '(foo?.bar!)()',
+      code: noFormat`(foo?.bar!)()`,
       errors: [
         {
           messageId: 'noNonNullOptionalChain',
           suggestions: [
             {
               messageId: 'suggestRemovingNonNull',
-              output: '(foo?.bar)()',
+              output: noFormat`(foo?.bar)()`,
             },
           ],
         },
diff --git a/packages/eslint-plugin/tests/rules/no-non-null-assertion.test.ts b/packages/eslint-plugin/tests/rules/no-non-null-assertion.test.ts
index 3bced219288..e9fae587f55 100644
--- a/packages/eslint-plugin/tests/rules/no-non-null-assertion.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-non-null-assertion.test.ts
@@ -8,16 +8,16 @@ const ruleTester = new RuleTester({
 ruleTester.run('no-non-null-assertion', rule, {
   valid: [
     //
-    'x',
-    'x.y',
-    'x.y.z',
-    'x?.y.z',
-    'x?.y?.z',
-    '!x',
+    'x;',
+    'x.y;',
+    'x.y.z;',
+    'x?.y.z;',
+    'x?.y?.z;',
+    '!x;',
   ],
   invalid: [
     {
-      code: 'x!',
+      code: 'x!;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -28,7 +28,7 @@ ruleTester.run('no-non-null-assertion', rule, {
       ],
     },
     {
-      code: 'x!.y',
+      code: 'x!.y;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -37,14 +37,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x?.y',
+              output: 'x?.y;',
             },
           ],
         },
       ],
     },
     {
-      code: 'x.y!',
+      code: 'x.y!;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -55,7 +55,7 @@ ruleTester.run('no-non-null-assertion', rule, {
       ],
     },
     {
-      code: '!x!.y',
+      code: '!x!.y;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -64,14 +64,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: '!x?.y',
+              output: '!x?.y;',
             },
           ],
         },
       ],
     },
     {
-      code: 'x!.y?.z',
+      code: 'x!.y?.z;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -80,14 +80,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x?.y?.z',
+              output: 'x?.y?.z;',
             },
           ],
         },
       ],
     },
     {
-      code: 'x![y]',
+      code: 'x![y];',
       errors: [
         {
           messageId: 'noNonNull',
@@ -96,14 +96,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x?.[y]',
+              output: 'x?.[y];',
             },
           ],
         },
       ],
     },
     {
-      code: 'x![y]?.z',
+      code: 'x![y]?.z;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -112,14 +112,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x?.[y]?.z',
+              output: 'x?.[y]?.z;',
             },
           ],
         },
       ],
     },
     {
-      code: 'x.y.z!()',
+      code: 'x.y.z!();',
       errors: [
         {
           messageId: 'noNonNull',
@@ -128,14 +128,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x.y.z?.()',
+              output: 'x.y.z?.();',
             },
           ],
         },
       ],
     },
     {
-      code: 'x.y?.z!()',
+      code: 'x.y?.z!();',
       errors: [
         {
           messageId: 'noNonNull',
@@ -144,7 +144,7 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x.y?.z?.()',
+              output: 'x.y?.z?.();',
             },
           ],
         },
@@ -152,7 +152,7 @@ ruleTester.run('no-non-null-assertion', rule, {
     },
     // some weirder cases that are stupid but valid
     {
-      code: 'x!!!',
+      code: 'x!!!;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -178,7 +178,7 @@ ruleTester.run('no-non-null-assertion', rule, {
       ],
     },
     {
-      code: 'x!!.y',
+      code: 'x!!.y;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -188,7 +188,7 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x!?.y',
+              output: 'x!?.y;',
             },
           ],
         },
@@ -202,7 +202,7 @@ ruleTester.run('no-non-null-assertion', rule, {
       ],
     },
     {
-      code: 'x.y!!',
+      code: 'x.y!!;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -221,7 +221,7 @@ ruleTester.run('no-non-null-assertion', rule, {
       ],
     },
     {
-      code: 'x.y.z!!()',
+      code: 'x.y.z!!();',
       errors: [
         {
           messageId: 'noNonNull',
@@ -231,7 +231,7 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x.y.z!?.()',
+              output: 'x.y.z!?.();',
             },
           ],
         },
@@ -245,7 +245,7 @@ ruleTester.run('no-non-null-assertion', rule, {
       ],
     },
     {
-      code: 'x!?.[y].z',
+      code: 'x!?.[y].z;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -254,14 +254,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x?.[y].z',
+              output: 'x?.[y].z;',
             },
           ],
         },
       ],
     },
     {
-      code: 'x!?.y.z',
+      code: 'x!?.y.z;',
       errors: [
         {
           messageId: 'noNonNull',
@@ -270,14 +270,14 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x?.y.z',
+              output: 'x?.y.z;',
             },
           ],
         },
       ],
     },
     {
-      code: 'x.y.z!?.()',
+      code: 'x.y.z!?.();',
       errors: [
         {
           messageId: 'noNonNull',
@@ -286,7 +286,7 @@ ruleTester.run('no-non-null-assertion', rule, {
           suggestions: [
             {
               messageId: 'suggestOptionalChain',
-              output: 'x.y.z?.()',
+              output: 'x.y.z?.();',
             },
           ],
         },
diff --git a/packages/eslint-plugin/tests/rules/no-parameter-properties.test.ts b/packages/eslint-plugin/tests/rules/no-parameter-properties.test.ts
index 2a2292d5861..f4f7fb03d2d 100644
--- a/packages/eslint-plugin/tests/rules/no-parameter-properties.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-parameter-properties.test.ts
@@ -9,107 +9,107 @@ ruleTester.run('no-parameter-properties', rule, {
   valid: [
     `
 class Foo {
-    constructor(name: string) {}
+  constructor(name: string) {}
 }
-        `,
+    `,
     `
 class Foo {
-    constructor(...name: string[]) {}
+  constructor(...name: string[]) {}
 }
-        `,
+    `,
     `
 class Foo {
-    constructor(name: string, age: number) {}
+  constructor(name: string, age: number) {}
 }
-        `,
+    `,
     `
 class Foo {
-    constructor(name: string);
-    constructor(name: string, age?: number) {}
+  constructor(name: string);
+  constructor(name: string, age?: number) {}
 }
-        `,
+    `,
     {
       code: `
 class Foo {
-    constructor(readonly name: string) { }
+  constructor(readonly name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['readonly'] }],
     },
     {
       code: `
 class Foo {
-    constructor(private name: string) { }
+  constructor(private name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['private'] }],
     },
     {
       code: `
 class Foo {
-    constructor(protected name: string) { }
+  constructor(protected name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['protected'] }],
     },
     {
       code: `
 class Foo {
-    constructor(public name: string) { }
+  constructor(public name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['public'] }],
     },
     {
       code: `
 class Foo {
-    constructor(private readonly name: string) { }
+  constructor(private readonly name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['private readonly'] }],
     },
     {
       code: `
 class Foo {
-    constructor(protected readonly name: string) { }
+  constructor(protected readonly name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['protected readonly'] }],
     },
     {
       code: `
 class Foo {
-    constructor(public readonly name: string) { }
+  constructor(public readonly name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['public readonly'] }],
     },
     {
       code: `
 class Foo {
-    constructor(readonly name: string, private age: number) { }
+  constructor(readonly name: string, private age: number) {}
 }
-            `,
+      `,
       options: [{ allows: ['readonly', 'private'] }],
     },
     {
       code: `
 class Foo {
-    constructor(public readonly name: string, private age: number) { }
+  constructor(public readonly name: string, private age: number) {}
 }
-            `,
+      `,
       options: [{ allows: ['public readonly', 'private'] }],
     },
     // Semantically invalid test case
     `
 class Foo {
-    constructor(private ...name: string[]) {}
+  constructor(private ...name: string[]) {}
 }
     `,
     // Semantically invalid test case
     `
 class Foo {
-    constructor(private [test]: [string]) {}
+  constructor(private [test]: [string]) {}
 }
     `,
   ],
@@ -117,9 +117,9 @@ class Foo {
     {
       code: `
 class Foo {
-    constructor(readonly name: string) {}
+  constructor(readonly name: string) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -127,16 +127,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private name: string) {}
+  constructor(private name: string) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -144,16 +144,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(protected name: string) {}
+  constructor(protected name: string) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -161,16 +161,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(public name: string) {}
+  constructor(public name: string) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -178,16 +178,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private readonly name: string) {}
+  constructor(private readonly name: string) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -195,16 +195,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(protected readonly name: string) {}
+  constructor(protected readonly name: string) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -212,16 +212,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(public readonly name: string) {}
+  constructor(public readonly name: string) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -229,16 +229,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(public name: string, age: number) {}
+  constructor(public name: string, age: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -246,16 +246,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private name: string, private age: number) {}
+  constructor(private name: string, private age: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -263,7 +263,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -271,16 +271,16 @@ class Foo {
             parameter: 'age',
           },
           line: 3,
-          column: 39,
+          column: 37,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(protected name: string, protected age: number) {}
+  constructor(protected name: string, protected age: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -288,7 +288,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -296,16 +296,16 @@ class Foo {
             parameter: 'age',
           },
           line: 3,
-          column: 41,
+          column: 39,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(public name: string, public age: number) {}
+  constructor(public name: string, public age: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -313,7 +313,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -321,17 +321,17 @@ class Foo {
             parameter: 'age',
           },
           line: 3,
-          column: 38,
+          column: 36,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(name: string);
-    constructor(private name: string, age?: number) {}
+  constructor(name: string);
+  constructor(private name: string, age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -339,17 +339,17 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private name: string);
-    constructor(private name: string, age?: number) {}
+  constructor(private name: string);
+  constructor(private name: string, age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -357,7 +357,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -365,17 +365,17 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private name: string);
-    constructor(private name: string, private age?: number) {}
+  constructor(private name: string);
+  constructor(private name: string, private age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -383,7 +383,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -391,7 +391,7 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -399,17 +399,17 @@ class Foo {
             parameter: 'age',
           },
           line: 4,
-          column: 39,
+          column: 37,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(name: string);
-    constructor(protected name: string, age?: number) {}
+  constructor(name: string);
+  constructor(protected name: string, age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -417,17 +417,17 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(protected name: string);
-    constructor(protected name: string, age?: number) {}
+  constructor(protected name: string);
+  constructor(protected name: string, age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -435,7 +435,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -443,17 +443,17 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(protected name: string);
-    constructor(protected name: string, protected age?: number) {}
+  constructor(protected name: string);
+  constructor(protected name: string, protected age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -461,7 +461,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -469,7 +469,7 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -477,17 +477,17 @@ class Foo {
             parameter: 'age',
           },
           line: 4,
-          column: 41,
+          column: 39,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(name: string);
-    constructor(public name: string, age?: number) {}
+  constructor(name: string);
+  constructor(public name: string, age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -495,17 +495,17 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(public name: string);
-    constructor(public name: string, age?: number) {}
+  constructor(public name: string);
+  constructor(public name: string, age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -513,7 +513,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -521,17 +521,17 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(public name: string);
-    constructor(public name: string, public age?: number) {}
+  constructor(public name: string);
+  constructor(public name: string, public age?: number) {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noParamProp',
@@ -539,7 +539,7 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -547,7 +547,7 @@ class Foo {
             parameter: 'name',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
         {
           messageId: 'noParamProp',
@@ -555,7 +555,7 @@ class Foo {
             parameter: 'age',
           },
           line: 4,
-          column: 38,
+          column: 36,
         },
       ],
     },
@@ -563,9 +563,9 @@ class Foo {
     {
       code: `
 class Foo {
-    constructor(readonly name: string) {}
+  constructor(readonly name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['private'] }],
       errors: [
         {
@@ -574,16 +574,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private name: string) {}
+  constructor(private name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['readonly'] }],
       errors: [
         {
@@ -592,16 +592,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(protected name: string) {}
+  constructor(protected name: string) {}
 }
-            `,
+      `,
       options: [
         {
           allows: ['readonly', 'private', 'public', 'protected readonly'],
@@ -614,16 +614,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(public name: string) {}
+  constructor(public name: string) {}
 }
-            `,
+      `,
       options: [
         {
           allows: [
@@ -642,16 +642,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private readonly name: string) {}
+  constructor(private readonly name: string) {}
 }
-            `,
+      `,
       options: [{ allows: ['readonly', 'private'] }],
       errors: [
         {
@@ -660,16 +660,16 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(protected readonly name: string) {}
+  constructor(protected readonly name: string) {}
 }
-            `,
+      `,
       options: [
         {
           allows: [
@@ -687,17 +687,17 @@ class Foo {
             parameter: 'name',
           },
           line: 3,
-          column: 17,
+          column: 15,
         },
       ],
     },
     {
       code: `
 class Foo {
-    constructor(private name: string);
-    constructor(private name: string, protected age?: number) {}
+  constructor(private name: string);
+  constructor(private name: string, protected age?: number) {}
 }
-            `,
+      `,
       options: [{ allows: ['private'] }],
       errors: [
         {
@@ -706,7 +706,7 @@ class Foo {
             parameter: 'age',
           },
           line: 4,
-          column: 39,
+          column: 37,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/no-require-imports.test.ts b/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
index ef49e4df1bf..606e4c47ce2 100644
--- a/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-require-imports.test.ts
@@ -10,17 +10,17 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-require-imports', rule, {
   valid: [
-    "import {l} from 'lib'",
-    "var lib3 = load('not_an_import')",
-    'var lib4 = lib2.subImport',
-    'var lib7 = 700',
-    'import lib9 = lib2.anotherSubImport',
-    "import lib10 from 'lib10'",
-    "var lib3 = load?.('not_an_import')",
+    "import { l } from 'lib';",
+    "var lib3 = load('not_an_import');",
+    'var lib4 = lib2.subImport;',
+    'var lib7 = 700;',
+    'import lib9 = lib2.anotherSubImport;',
+    "import lib10 from 'lib10';",
+    "var lib3 = load?.('not_an_import');",
   ],
   invalid: [
     {
-      code: "var lib = require('lib')",
+      code: "var lib = require('lib');",
       errors: [
         {
           messageId: 'noRequireImports',
@@ -30,7 +30,7 @@ ruleTester.run('no-require-imports', rule, {
       ],
     },
     {
-      code: "let lib2 = require('lib2')",
+      code: "let lib2 = require('lib2');",
       errors: [
         {
           messageId: 'noRequireImports',
@@ -40,22 +40,25 @@ ruleTester.run('no-require-imports', rule, {
       ],
     },
     {
-      code: "var lib5 = require('lib5'), lib6 = require('lib6')",
+      code: `
+var lib5 = require('lib5'),
+  lib6 = require('lib6');
+      `,
       errors: [
         {
           messageId: 'noRequireImports',
-          line: 1,
+          line: 2,
           column: 12,
         },
         {
           messageId: 'noRequireImports',
-          line: 1,
-          column: 36,
+          line: 3,
+          column: 10,
         },
       ],
     },
     {
-      code: "import lib8 = require('lib8')",
+      code: "import lib8 = require('lib8');",
       errors: [
         {
           messageId: 'noRequireImports',
@@ -65,7 +68,7 @@ ruleTester.run('no-require-imports', rule, {
       ],
     },
     {
-      code: "var lib = require?.('lib')",
+      code: "var lib = require?.('lib');",
       errors: [
         {
           messageId: 'noRequireImports',
@@ -75,7 +78,7 @@ ruleTester.run('no-require-imports', rule, {
       ],
     },
     {
-      code: "let lib2 = require?.('lib2')",
+      code: "let lib2 = require?.('lib2');",
       errors: [
         {
           messageId: 'noRequireImports',
@@ -85,17 +88,20 @@ ruleTester.run('no-require-imports', rule, {
       ],
     },
     {
-      code: "var lib5 = require?.('lib5'), lib6 = require?.('lib6')",
+      code: `
+var lib5 = require?.('lib5'),
+  lib6 = require?.('lib6');
+      `,
       errors: [
         {
           messageId: 'noRequireImports',
-          line: 1,
+          line: 2,
           column: 12,
         },
         {
           messageId: 'noRequireImports',
-          line: 1,
-          column: 38,
+          line: 3,
+          column: 10,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/no-this-alias.test.ts b/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
index 0cbd35dae19..43806a67fd9 100644
--- a/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-this-alias.test.ts
@@ -29,7 +29,7 @@ const { length } = this;
 const { length, toString } = this;
 const [foo] = this;
 const [foo, bar] = this;
-`,
+      `,
       options: [
         {
           allowDestructuring: true,
@@ -47,9 +47,9 @@ const [foo, bar] = this;
     // https://github.com/bradzacher/eslint-plugin-typescript/issues/281
     `
 declare module 'foo' {
-    declare const aVar: string
+  declare const aVar: string;
 }
-        `,
+    `,
   ],
 
   invalid: [
@@ -80,35 +80,35 @@ declare module 'foo' {
 var unscoped = this;
 
 function testFunction() {
-    let inFunction = this;
+  let inFunction = this;
 }
 const testLambda = () => {
-    const inLambda = this;
+  const inLambda = this;
 };
-`,
+      `,
       errors: [idError, idError, idError],
     },
     {
       code: `
 class TestClass {
-    constructor() {
-        const inConstructor = this;
-        const asThis: this = this;
+  constructor() {
+    const inConstructor = this;
+    const asThis: this = this;
 
-        const asString = "this";
-        const asArray = [this];
-        const asArrayString = ["this"];
-    }
+    const asString = 'this';
+    const asArray = [this];
+    const asArrayString = ['this'];
+  }
 
-    public act(scope: this = this) {
-        const inMemberFunction = this;
-        const { act } = this;
-        const { act, constructor } = this;
-        const [foo] = this;
-        const [foo, bar] = this;
-    }
+  public act(scope: this = this) {
+    const inMemberFunction = this;
+    const { act } = this;
+    const { act, constructor } = this;
+    const [foo] = this;
+    const [foo, bar] = this;
+  }
 }
-`,
+      `,
       options: [
         {
           allowDestructuring: false,
diff --git a/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts b/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts
index 451e88262a3..1367c6a8f69 100644
--- a/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts
@@ -14,8 +14,8 @@ const ruleTester = new RuleTester({
 ruleTester.run('no-throw-literal', rule, {
   valid: [
     'throw new Error();',
-    'throw new Error("error");',
-    'throw Error("error");',
+    "throw new Error('error');",
+    "throw Error('error');",
     `
 const e = new Error();
 throw e;
@@ -35,27 +35,27 @@ throw foo();
     `,
     `
 const foo = {
-  bar: new Error()
-}
+  bar: new Error(),
+};
 throw foo.bar;
     `,
     `
 const foo = {
-  bar: new Error()
-}
+  bar: new Error(),
+};
 
 throw foo['bar'];
     `,
     `
 const foo = {
-  bar: new Error()
-}
+  bar: new Error(),
+};
 
 const bar = 'bar';
 throw foo[bar];
     `,
     `
-class CustomError extends Error {};
+class CustomError extends Error {}
 throw new CustomError();
     `,
     `
@@ -63,14 +63,23 @@ class CustomError1 extends Error {}
 class CustomError2 extends CustomError1 {}
 throw new CustomError();
     `,
-    'throw foo = new Error();',
-    'throw 1, 2, new Error();',
-    'throw "literal" && new Error();',
-    'throw new Error() || "literal"',
-    'throw foo ? new Error() : "literal";',
-    'throw foo ? "literal" : new Error();',
-    'function* foo() { let index = 0; throw yield index++; }',
-    'async function foo() { throw await bar; }',
+    'throw (foo = new Error());',
+    'throw (1, 2, new Error());',
+    "throw 'literal' && new Error();",
+    "throw new Error() || 'literal';",
+    "throw foo ? new Error() : 'literal';",
+    "throw foo ? 'literal' : new Error();",
+    `
+function* foo() {
+  let index = 0;
+  throw yield index++;
+}
+    `,
+    `
+async function foo() {
+  throw await bar;
+}
+    `,
     `
 import { Error } from './missing';
 throw Error;
@@ -98,7 +107,7 @@ throw new CustomError();
       ],
     },
     {
-      code: 'throw new String("");',
+      code: "throw new String('');",
       errors: [
         {
           messageId: 'object',
@@ -106,7 +115,7 @@ throw new CustomError();
       ],
     },
     {
-      code: 'throw "error";',
+      code: "throw 'error';",
       errors: [
         {
           messageId: 'object',
@@ -146,7 +155,7 @@ throw new CustomError();
       ],
     },
     {
-      code: 'throw "a" + "b";',
+      code: "throw 'a' + 'b';",
       errors: [
         {
           messageId: 'object',
@@ -165,7 +174,7 @@ throw a + 'b';
       ],
     },
     {
-      code: 'throw foo = "error";',
+      code: "throw (foo = 'error');",
       errors: [
         {
           messageId: 'object',
@@ -173,7 +182,7 @@ throw a + 'b';
       ],
     },
     {
-      code: 'throw new Error(), 1, 2, 3;',
+      code: 'throw (new Error(), 1, 2, 3);',
       errors: [
         {
           messageId: 'object',
@@ -181,7 +190,7 @@ throw a + 'b';
       ],
     },
     {
-      code: 'throw "literal" && "not an Error";',
+      code: "throw 'literal' && 'not an Error';",
       errors: [
         {
           messageId: 'object',
@@ -189,7 +198,7 @@ throw a + 'b';
       ],
     },
     {
-      code: 'throw foo ? "not an Error" : "literal";',
+      code: "throw foo ? 'not an Error' : 'literal';",
       errors: [
         {
           messageId: 'object',
@@ -197,7 +206,7 @@ throw a + 'b';
       ],
     },
     {
-      code: 'throw `${err}`',
+      code: 'throw `${err}`;',
       errors: [
         {
           messageId: 'object',
@@ -217,8 +226,7 @@ throw err;
     },
     {
       code: `
-function foo(msg) {
-}
+function foo(msg) {}
 throw foo('error');
       `,
       errors: [
@@ -230,7 +238,7 @@ throw foo('error');
     {
       code: `
 const foo = {
-  msg: 'error'
+  msg: 'error',
 };
 throw foo.msg;
       `,
@@ -243,7 +251,7 @@ throw foo.msg;
     {
       code: `
 const foo = {
-  msg: undefined
+  msg: undefined,
 };
 throw foo.msg;
       `,
diff --git a/packages/eslint-plugin/tests/rules/no-type-alias.test.ts b/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
index 9d6b0cd0f97..29c4f85b2f4 100644
--- a/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-type-alias.test.ts
@@ -64,11 +64,11 @@ ruleTester.run('no-type-alias', rule, {
       options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [{ allowAliases: 'always' }],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
@@ -124,11 +124,11 @@ ruleTester.run('no-type-alias', rule, {
       options: [{ allowAliases: 'in-intersections' }],
     },
     {
-      code: 'type Foo = 1 | 2 & 3;',
+      code: 'type Foo = 1 | (2 & 3);',
       options: [{ allowAliases: 'always' }],
     },
     {
-      code: 'type Foo = 1 | 2 & 3;',
+      code: 'type Foo = 1 | (2 & 3);',
       options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
@@ -163,42 +163,42 @@ ruleTester.run('no-type-alias', rule, {
       code: `
 interface Bar {}
 type Foo = Bar | string;
-            `,
+      `,
       options: [{ allowAliases: 'always' }],
     },
     {
       code: `
 interface Bar {}
 type Foo = Bar | string;
-            `,
+      `,
       options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
       code: `
 interface Bar {}
 type Foo = Bar | string;
-            `,
+      `,
       options: [{ allowAliases: 'in-unions' }],
     },
     {
       code: `
 interface Bar {}
 type Foo = Bar & string;
-            `,
+      `,
       options: [{ allowAliases: 'always' }],
     },
     {
       code: `
 interface Bar {}
 type Foo = Bar & string;
-            `,
+      `,
       options: [{ allowAliases: 'in-unions-and-intersections' }],
     },
     {
       code: `
 interface Bar {}
 type Foo = Bar & string;
-            `,
+      `,
       options: [{ allowAliases: 'in-intersections' }],
     },
     {
@@ -292,74 +292,91 @@ type Foo = Bar & string;
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
+  readonly [P in keyof T]: T[P];
 };
-            `,
+      `,
       options: [{ allowMappedTypes: 'always' }],
     },
     {
       code: `
-type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} | {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
+      `,
       options: [{ allowMappedTypes: 'always' }],
     },
     {
       code: `
-type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} | {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
+      `,
       options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
     },
     {
       code: `
-type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} | {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
+      `,
       options: [{ allowMappedTypes: 'in-unions' }],
     },
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} & {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+  readonly [P in keyof T]: T[P];
+} &
+  {
+    readonly [P in keyof T]: T[P];
+  };
+      `,
       options: [{ allowMappedTypes: 'always' }],
     },
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} & {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+  readonly [P in keyof T]: T[P];
+} &
+  {
+    readonly [P in keyof T]: T[P];
+  };
+      `,
       options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
     },
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} & {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+  readonly [P in keyof T]: T[P];
+} &
+  {
+    readonly [P in keyof T]: T[P];
+  };
+      `,
       options: [{ allowMappedTypes: 'in-intersections' }],
     },
     {
-      code:
-        'export type ClassValue = string | number | ClassDictionary | ClassArray | undefined | null | false;',
+      code: `
+export type ClassValue =
+  | string
+  | number
+  | ClassDictionary
+  | ClassArray
+  | undefined
+  | null
+  | false;
+      `,
       options: [
         {
           allowAliases: 'in-unions-and-intersections',
@@ -378,7 +395,7 @@ type Foo<T> = {
       options: [{ allowAliases: 'in-unions' }],
     },
     {
-      code: 'type Foo = keyof [string]',
+      code: 'type Foo = keyof [string];',
       options: [{ allowTupleTypes: 'always' }],
     },
     {
@@ -395,7 +412,7 @@ type Foo<T> = {
     },
     {
       code:
-        'type Foo = [string] & [number, number] | [number, number, number];',
+        'type Foo = ([string] & [number, number]) | [number, number, number];',
       options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
@@ -416,7 +433,7 @@ type Foo<T> = {
     },
     {
       code:
-        'type Foo = [string] & [number, number] | readonly [number, number, number];',
+        'type Foo = ([string] & [number, number]) | readonly [number, number, number];',
       options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
@@ -437,7 +454,7 @@ type Foo<T> = {
     },
     {
       code:
-        'type Foo = [string] & [number, number] | keyof [number, number, number];',
+        'type Foo = ([string] & [number, number]) | keyof [number, number, number];',
       options: [{ allowTupleTypes: 'in-unions-and-intersections' }],
     },
     {
@@ -451,7 +468,7 @@ type Foo<T> = {
   ],
   invalid: [
     {
-      code: "type Foo = 'a'",
+      code: "type Foo = 'a';",
       errors: [
         {
           messageId: 'noTypeAlias',
@@ -464,7 +481,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: "type Foo = 'a'",
+      code: "type Foo = 'a';",
       options: [{ allowAliases: 'never' }],
       errors: [
         {
@@ -1154,7 +1171,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       errors: [
         {
           messageId: 'noCompositionAlias',
@@ -1172,7 +1189,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          column: 19,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1181,12 +1198,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          column: 25,
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [{ allowLiterals: 'in-intersections' }],
       errors: [
         {
@@ -1205,7 +1222,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          column: 19,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1214,12 +1231,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          column: 25,
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [{ allowAliases: 'never' }],
       errors: [
         {
@@ -1238,7 +1255,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          column: 19,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1247,12 +1264,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          column: 25,
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [{ allowAliases: 'never', allowLiterals: 'in-intersections' }],
       errors: [
         {
@@ -1271,7 +1288,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          column: 19,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1280,12 +1297,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          column: 25,
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [{ allowAliases: 'in-unions' }],
       errors: [
         {
@@ -1295,7 +1312,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          column: 19,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1304,12 +1321,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          column: 25,
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [
         {
           allowAliases: 'in-unions',
@@ -1324,7 +1341,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 18,
+          column: 19,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1333,12 +1350,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 24,
+          column: 25,
         },
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [{ allowAliases: 'in-intersections' }],
       errors: [
         {
@@ -1353,7 +1370,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: "type Foo = 'a' | 'b' & 'c';",
+      code: "type Foo = 'a' | ('b' & 'c');",
       options: [
         {
           allowAliases: 'in-intersections',
@@ -1792,7 +1809,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       errors: [
         {
           messageId: 'noCompositionAlias',
@@ -1810,7 +1827,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1819,12 +1836,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 32,
+          column: 33,
         },
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       options: [{ allowLiterals: 'in-unions' }],
       errors: [
         {
@@ -1843,7 +1860,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1852,12 +1869,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 32,
+          column: 33,
         },
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       options: [{ allowAliases: 'never' }],
       errors: [
         {
@@ -1876,7 +1893,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1885,12 +1902,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 32,
+          column: 33,
         },
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       options: [{ allowAliases: 'never', allowLiterals: 'in-unions' }],
       errors: [
         {
@@ -1909,7 +1926,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1918,12 +1935,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 32,
+          column: 33,
         },
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       options: [{ allowAliases: 'in-unions' }],
       errors: [
         {
@@ -1933,7 +1950,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1942,12 +1959,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 32,
+          column: 33,
         },
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
       errors: [
         {
@@ -1957,7 +1974,7 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
         {
           messageId: 'noCompositionAlias',
@@ -1966,12 +1983,12 @@ type Foo<T> = {
             compositionType: 'intersection',
           },
           line: 1,
-          column: 32,
+          column: 33,
         },
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       options: [{ allowAliases: 'in-intersections' }],
       errors: [
         {
@@ -1986,7 +2003,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = string | string[] & number;',
+      code: 'type Foo = string | (string[] & number);',
       options: [
         {
           allowAliases: 'in-intersections',
@@ -2009,7 +2026,7 @@ type Foo<T> = {
       code: `
 interface Bar {}
 type Foo = Bar;
-            `,
+      `,
       errors: [
         {
           messageId: 'noTypeAlias',
@@ -2025,7 +2042,7 @@ type Foo = Bar;
       code: `
 interface Bar {}
 type Foo = Bar;
-            `,
+      `,
       options: [{ allowAliases: 'never' }],
       errors: [
         {
@@ -2042,7 +2059,7 @@ type Foo = Bar;
       code: `
 interface Bar {}
 type Foo = Bar;
-            `,
+      `,
       options: [{ allowAliases: 'in-unions' }],
       errors: [
         {
@@ -2059,7 +2076,7 @@ type Foo = Bar;
       code: `
 interface Bar {}
 type Foo = Bar;
-            `,
+      `,
       options: [{ allowAliases: 'in-intersections' }],
       errors: [
         {
@@ -2076,7 +2093,7 @@ type Foo = Bar;
       code: `
 interface Bar {}
 type Foo = Bar;
-            `,
+      `,
       options: [{ allowAliases: 'in-unions-and-intersections' }],
       errors: [
         {
@@ -2093,7 +2110,7 @@ type Foo = Bar;
       code: `
 interface Bar {}
 type Foo = Bar | {};
-            `,
+      `,
       errors: [
         {
           messageId: 'noCompositionAlias',
@@ -2119,7 +2136,7 @@ type Foo = Bar | {};
       code: `
 interface Bar {}
 type Foo = Bar | {};
-            `,
+      `,
       options: [{ allowAliases: 'never' }],
       errors: [
         {
@@ -2146,7 +2163,7 @@ type Foo = Bar | {};
       code: `
 interface Bar {}
 type Foo = Bar | {};
-            `,
+      `,
       options: [{ allowAliases: 'in-unions' }],
       errors: [
         {
@@ -2164,7 +2181,7 @@ type Foo = Bar | {};
       code: `
 interface Bar {}
 type Foo = Bar | {};
-            `,
+      `,
       options: [{ allowAliases: 'in-intersections' }],
       errors: [
         {
@@ -2191,7 +2208,7 @@ type Foo = Bar | {};
       code: `
 interface Bar {}
 type Foo = Bar | {};
-            `,
+      `,
       options: [{ allowAliases: 'in-unions-and-intersections' }],
       errors: [
         {
@@ -2209,7 +2226,7 @@ type Foo = Bar | {};
       code: `
 interface Bar {}
 type Foo = Bar & {};
-            `,
+      `,
       errors: [
         {
           messageId: 'noCompositionAlias',
@@ -2235,7 +2252,7 @@ type Foo = Bar & {};
       code: `
 interface Bar {}
 type Foo = Bar & {};
-            `,
+      `,
       options: [{ allowAliases: 'never' }],
       errors: [
         {
@@ -2262,7 +2279,7 @@ type Foo = Bar & {};
       code: `
 interface Bar {}
 type Foo = Bar & {};
-            `,
+      `,
       options: [{ allowAliases: 'in-unions' }],
       errors: [
         {
@@ -2289,7 +2306,7 @@ type Foo = Bar & {};
       code: `
 interface Bar {}
 type Foo = Bar & {};
-            `,
+      `,
       options: [{ allowAliases: 'in-intersections' }],
       errors: [
         {
@@ -2307,7 +2324,7 @@ type Foo = Bar & {};
       code: `
 interface Bar {}
 type Foo = Bar & {};
-            `,
+      `,
       options: [{ allowAliases: 'in-unions-and-intersections' }],
       errors: [
         {
@@ -2645,7 +2662,7 @@ type Foo = Bar & {};
       ],
     },
     {
-      code: "type Foo = string & {} | 'a' | 1;",
+      code: "type Foo = (string & {}) | 'a' | 1;",
       options: [{ allowAliases: 'in-unions', allowLiterals: 'in-unions' }],
       errors: [
         {
@@ -2655,7 +2672,7 @@ type Foo = Bar & {};
             compositionType: 'intersection',
           },
           line: 1,
-          column: 12,
+          column: 13,
         },
         {
           messageId: 'noCompositionAlias',
@@ -2664,12 +2681,12 @@ type Foo = Bar & {};
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
       ],
     },
     {
-      code: "type Foo = string & {} | 'a' | 1;",
+      code: "type Foo = (string & {}) | 'a' | 1;",
       options: [
         {
           allowAliases: 'in-intersections',
@@ -2684,7 +2701,7 @@ type Foo = Bar & {};
             compositionType: 'intersection',
           },
           line: 1,
-          column: 21,
+          column: 22,
         },
         {
           messageId: 'noCompositionAlias',
@@ -2693,7 +2710,7 @@ type Foo = Bar & {};
             compositionType: 'union',
           },
           line: 1,
-          column: 26,
+          column: 28,
         },
         {
           messageId: 'noCompositionAlias',
@@ -2702,16 +2719,16 @@ type Foo = Bar & {};
             compositionType: 'union',
           },
           line: 1,
-          column: 32,
+          column: 34,
         },
       ],
     },
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
+  readonly [P in keyof T]: T[P];
 };
-            `,
+      `,
       errors: [
         {
           messageId: 'noTypeAlias',
@@ -2726,9 +2743,9 @@ type Foo<T> = {
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
+  readonly [P in keyof T]: T[P];
 };
-            `,
+      `,
       options: [{ allowMappedTypes: 'never' }],
       errors: [
         {
@@ -2744,9 +2761,9 @@ type Foo<T> = {
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
+  readonly [P in keyof T]: T[P];
 };
-            `,
+      `,
       options: [{ allowMappedTypes: 'in-unions' }],
       errors: [
         {
@@ -2762,9 +2779,9 @@ type Foo<T> = {
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
+  readonly [P in keyof T]: T[P];
 };
-            `,
+      `,
       options: [{ allowMappedTypes: 'in-intersections' }],
       errors: [
         {
@@ -2780,9 +2797,9 @@ type Foo<T> = {
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
+  readonly [P in keyof T]: T[P];
 };
-            `,
+      `,
       options: [{ allowMappedTypes: 'in-unions-and-intersections' }],
       errors: [
         {
@@ -2797,12 +2814,14 @@ type Foo<T> = {
     },
     {
       code: `
-type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} | {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
+      `,
       errors: [
         {
           messageId: 'noCompositionAlias',
@@ -2810,8 +2829,8 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'union',
           },
-          line: 2,
-          column: 15,
+          line: 3,
+          column: 5,
         },
         {
           messageId: 'noCompositionAlias',
@@ -2819,19 +2838,21 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'union',
           },
-          line: 4,
+          line: 6,
           column: 5,
         },
       ],
     },
     {
       code: `
-type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} | {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
+      `,
       options: [{ allowMappedTypes: 'never' }],
       errors: [
         {
@@ -2840,8 +2861,8 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'union',
           },
-          line: 2,
-          column: 15,
+          line: 3,
+          column: 5,
         },
         {
           messageId: 'noCompositionAlias',
@@ -2849,19 +2870,21 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'union',
           },
-          line: 4,
+          line: 6,
           column: 5,
         },
       ],
     },
     {
       code: `
-type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} | {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+type Foo<T> =
+  | {
+      readonly [P in keyof T]: T[P];
+    }
+  | {
+      readonly [P in keyof T]: T[P];
+    };
+      `,
       options: [{ allowMappedTypes: 'in-intersections' }],
       errors: [
         {
@@ -2870,8 +2893,8 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'union',
           },
-          line: 2,
-          column: 15,
+          line: 3,
+          column: 5,
         },
         {
           messageId: 'noCompositionAlias',
@@ -2879,7 +2902,7 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'union',
           },
-          line: 4,
+          line: 6,
           column: 5,
         },
       ],
@@ -2887,11 +2910,12 @@ type Foo<T> = {
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} & {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+  readonly [P in keyof T]: T[P];
+} &
+  {
+    readonly [P in keyof T]: T[P];
+  };
+      `,
       errors: [
         {
           messageId: 'noCompositionAlias',
@@ -2908,19 +2932,20 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'intersection',
           },
-          line: 4,
-          column: 5,
+          line: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} & {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+  readonly [P in keyof T]: T[P];
+} &
+  {
+    readonly [P in keyof T]: T[P];
+  };
+      `,
       options: [{ allowMappedTypes: 'never' }],
       errors: [
         {
@@ -2938,19 +2963,20 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'intersection',
           },
-          line: 4,
-          column: 5,
+          line: 5,
+          column: 3,
         },
       ],
     },
     {
       code: `
 type Foo<T> = {
-    readonly [P in keyof T] : T[P]
-} & {
-    readonly [P in keyof T] : T[P]
-};
-            `,
+  readonly [P in keyof T]: T[P];
+} &
+  {
+    readonly [P in keyof T]: T[P];
+  };
+      `,
       options: [{ allowMappedTypes: 'in-unions' }],
       errors: [
         {
@@ -2968,8 +2994,8 @@ type Foo<T> = {
             typeName: 'Mapped types',
             compositionType: 'intersection',
           },
-          line: 4,
-          column: 5,
+          line: 5,
+          column: 3,
         },
       ],
     },
@@ -2988,7 +3014,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = [number] | [number, number]',
+      code: 'type Foo = [number] | [number, number];',
       options: [{ allowTupleTypes: 'never' }],
       errors: [
         {
@@ -3012,7 +3038,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = [number] & [number, number]',
+      code: 'type Foo = [number] & [number, number];',
       options: [{ allowTupleTypes: 'in-unions' }],
       errors: [
         {
@@ -3036,7 +3062,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = [number] | [number, number]',
+      code: 'type Foo = [number] | [number, number];',
       options: [{ allowTupleTypes: 'in-intersections' }],
       errors: [
         {
@@ -3087,7 +3113,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = readonly [number] | keyof [number, number]',
+      code: 'type Foo = readonly [number] | keyof [number, number];',
       options: [{ allowTupleTypes: 'never' }],
       errors: [
         {
@@ -3111,7 +3137,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = keyof [number] & [number, number]',
+      code: 'type Foo = keyof [number] & [number, number];',
       options: [{ allowTupleTypes: 'in-unions' }],
       errors: [
         {
@@ -3135,7 +3161,7 @@ type Foo<T> = {
       ],
     },
     {
-      code: 'type Foo = [number] | readonly [number, number]',
+      code: 'type Foo = [number] | readonly [number, number];',
       options: [{ allowTupleTypes: 'in-intersections' }],
       errors: [
         {
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts
index 1c6cfebeecc..6480d548906 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-boolean-literal-compare.test.ts
@@ -11,7 +11,7 @@ const ruleTester = new RuleTester({
   },
 });
 
-ruleTester.run('boolean-literal-compare', rule, {
+ruleTester.run('no-unnecessary-boolean-literal-compare', rule, {
   valid: [
     `
       declare const varAny: any;
@@ -49,33 +49,34 @@ ruleTester.run('boolean-literal-compare', rule, {
       declare const varBooleanOrUndefined: boolean | undefined;
       varBooleanOrUndefined === true;
     `,
-    `'false' === true;`,
-    `'true' === false;`,
+    "'false' === true;",
+    "'true' === false;",
   ],
 
   invalid: [
     {
-      code: `true === true`,
+      code: 'true === true;',
       errors: [
         {
           messageId: 'direct',
         },
       ],
-      output: `true`,
+      output: 'true;',
     },
     {
-      code: `false !== true`,
+      code: 'false !== true;',
       errors: [
         {
           messageId: 'negated',
         },
       ],
-      output: `!false`,
+      output: '!false;',
     },
     {
       code: `
         declare const varBoolean: boolean;
-        if (varBoolean !== false) { }
+        if (varBoolean !== false) {
+        }
       `,
       errors: [
         {
@@ -84,13 +85,15 @@ ruleTester.run('boolean-literal-compare', rule, {
       ],
       output: `
         declare const varBoolean: boolean;
-        if (varBoolean) { }
+        if (varBoolean) {
+        }
       `,
     },
     {
       code: `
         declare const varTrue: true;
-        if (varTrue !== true) { }
+        if (varTrue !== true) {
+        }
       `,
       errors: [
         {
@@ -99,7 +102,8 @@ ruleTester.run('boolean-literal-compare', rule, {
       ],
       output: `
         declare const varTrue: true;
-        if (!varTrue) { }
+        if (!varTrue) {
+        }
       `,
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
index f3adbc3a849..42f9e288b23 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-condition.test.ts
@@ -6,7 +6,7 @@ import rule, {
   Options,
   MessageId,
 } from '../../src/rules/no-unnecessary-condition';
-import { RuleTester, getFixturesRootDir } from '../RuleTester';
+import { RuleTester, getFixturesRootDir, noFormat } from '../RuleTester';
 
 const rootPath = getFixturesRootDir();
 
@@ -49,10 +49,14 @@ declare const b1: boolean;
 declare const b2: boolean;
 const t1 = b1 && b2;
 const t2 = b1 || b2;
-if(b1 && b2) {}
-while(b1 && b2) {}
-for (let i = 0; (b1 && b2); i++) { break; }
-const t1 = (b1 && b2) ? 'yes' : 'no'`,
+if (b1 && b2) {
+}
+while (b1 && b2) {}
+for (let i = 0; b1 && b2; i++) {
+  break;
+}
+const t1 = b1 && b2 ? 'yes' : 'no';
+    `,
     necessaryConditionTest('false | 5'), // Truthy literal and falsy literal
     necessaryConditionTest('boolean | "foo"'), // boolean and truthy literal
     necessaryConditionTest('0 | boolean'), // boolean and falsy literal
@@ -69,56 +73,60 @@ const t1 = (b1 && b2) ? 'yes' : 'no'`,
     // Generic type params
     `
 function test<T extends string>(t: T) {
-  return t ? 'yes' : 'no'
-}`,
+  return t ? 'yes' : 'no';
+}
+    `,
     `
 // Naked type param
 function test<T>(t: T) {
-  return t ? 'yes' : 'no'
-}`,
+  return t ? 'yes' : 'no';
+}
+    `,
     `
 // Naked type param in union
 function test<T>(t: T | []) {
-  return t ? 'yes' : 'no'
-}`,
+  return t ? 'yes' : 'no';
+}
+    `,
 
     // Boolean expressions
     `
 function test(a: string) {
-  return a === "a"
-}`,
+  return a === 'a';
+}
+    `,
 
     /**
      * Predicate functions
      **/
     // valid, with the flag off
     `
-[1,3,5].filter(() => true);
-[1,2,3].find(() => false);
+[1, 3, 5].filter(() => true);
+[1, 2, 3].find(() => false);
 function truthy() {
   return [];
 }
 function falsy() {}
-[1,3,5].filter(truthy);
-[1,2,3].find(falsy);
-`,
+[1, 3, 5].filter(truthy);
+[1, 2, 3].find(falsy);
+    `,
     {
       options: [{ checkArrayPredicates: true }],
       code: `
 // with literal arrow function
-[0,1,2].filter(x => x);
+[0, 1, 2].filter(x => x);
 
 // filter with named function
 function length(x: string) {
   return x.length;
 }
-["a", "b", ""].filter(length);
+['a', 'b', ''].filter(length);
 
 // with non-literal array
 function nonEmptyStrings(x: string[]) {
   return x.filter(length);
 }
-`,
+      `,
     },
     // Ignores non-array methods of the same name
     {
@@ -130,131 +138,145 @@ const notArray = {
 };
 notArray.filter(() => true);
 notArray.find(() => true);
-`,
+      `,
     },
 
     // Nullish coalescing operator
     `
 function test(a: string | null) {
-  return a ?? "default";
-}`,
+  return a ?? 'default';
+}
+    `,
     `
 function test(a: string | undefined) {
-  return a ?? "default";
-}`,
+  return a ?? 'default';
+}
+    `,
     `
 function test(a: string | null | undefined) {
-  return a ?? "default";
-}`,
+  return a ?? 'default';
+}
+    `,
     `
 function test(a: unknown) {
-  return a ?? "default";
-}`,
+  return a ?? 'default';
+}
+    `,
     // Indexing cases
     `
 declare const arr: object[];
-if(arr[42]) {} // looks unnecessary from the types, but isn't
+if (arr[42]) {
+} // looks unnecessary from the types, but isn't
 
 const tuple = [{}] as [object];
 declare const n: number;
-if(tuple[n]) {}
-`,
+if (tuple[n]) {
+}
+    `,
     // Optional-chaining indexing
     `
-declare const arr: Array<{value: string} & (() => void)>;
-if(arr[42]?.value) {}
+declare const arr: Array<{ value: string } & (() => void)>;
+if (arr[42]?.value) {
+}
 arr[41]?.();
 
 // An array access can "infect" deeper into the chain
-declare const arr2: Array<{x: {y: {z: object}}}>;
+declare const arr2: Array<{ x: { y: { z: object } } }>;
 arr2[42]?.x?.y?.z;
 
-const tuple = ["foo"] as const;
+const tuple = ['foo'] as const;
 declare const n: number;
 tuple[n]?.toUpperCase();
     `,
-    `if(arr?.[42]) {}`,
+    `
+if (arr?.[42]) {
+}
+    `,
     `
 declare const returnsArr: undefined | (() => string[]);
-if(returnsArr?.()[42]) {}
-returnsArr?.()[42]?.toUpperCase()`,
+if (returnsArr?.()[42]) {
+}
+returnsArr?.()[42]?.toUpperCase();
+    `,
     // nullish + array index
     `
 declare const arr: string[][];
 arr[x] ?? [];
-`,
+    `,
     // Supports ignoring the RHS
     {
       code: `
 declare const b1: boolean;
 declare const b2: true;
-if(b1 && b2) {}`,
+if (b1 && b2) {
+}
+      `,
       options: [{ ignoreRhs: true }],
     },
     {
       code: `
-while(true) {}
-for (;true;) {}
-do {} while(true)
+while (true) {}
+for (; true; ) {}
+do {} while (true);
       `,
       options: [{ allowConstantLoopConditions: true }],
     },
     `
 let foo: undefined | { bar: true };
 foo?.bar;
-`,
+    `,
     `
 let foo: null | { bar: true };
 foo?.bar;
-`,
+    `,
     `
 let foo: undefined;
 foo?.bar;
-`,
+    `,
     `
 let foo: undefined;
 foo?.bar.baz;
-`,
+    `,
     `
 let foo: null;
 foo?.bar;
-`,
+    `,
     `
 let anyValue: any;
 anyValue?.foo;
-`,
+    `,
     `
 let unknownValue: unknown;
 unknownValue?.foo;
-`,
+    `,
     `
 let foo: undefined | (() => {});
 foo?.();
-`,
+    `,
     `
 let foo: null | (() => {});
 foo?.();
-`,
+    `,
     `
 let foo: undefined;
 foo?.();
-`,
+    `,
     `
 let foo: undefined;
 foo?.().bar;
-`,
+    `,
     `
 let foo: null;
 foo?.();
-`,
+    `,
     `
 let anyValue: any;
 anyValue?.();
-`,
+    `,
     `
 let unknownValue: unknown;
 unknownValue?.();
-`,
+    `,
     'const foo = [1, 2, 3][0];',
   ],
   invalid: [
@@ -265,17 +287,21 @@ const b1 = true;
 declare const b2: boolean;
 const t1 = b1 && b2;
 const t2 = b1 || b2;
-if(b1 && b2) {}
-while(b1 && b2) {}
-for (let i = 0; (b1 && b2); i++) { break; }
-const t1 = (b1 && b2) ? 'yes' : 'no'`,
+if (b1 && b2) {
+}
+while (b1 && b2) {}
+for (let i = 0; b1 && b2; i++) {
+  break;
+}
+const t1 = b1 && b2 ? 'yes' : 'no';
+      `,
       errors: [
         ruleError(4, 12, 'alwaysTruthy'),
         ruleError(5, 12, 'alwaysTruthy'),
-        ruleError(6, 4, 'alwaysTruthy'),
-        ruleError(7, 7, 'alwaysTruthy'),
-        ruleError(8, 18, 'alwaysTruthy'),
-        ruleError(9, 13, 'alwaysTruthy'),
+        ruleError(6, 5, 'alwaysTruthy'),
+        ruleError(8, 8, 'alwaysTruthy'),
+        ruleError(9, 17, 'alwaysTruthy'),
+        ruleError(12, 12, 'alwaysTruthy'),
       ],
     },
     // Ensure that it's complaining about the right things
@@ -292,50 +318,56 @@ const t1 = (b1 && b2) ? 'yes' : 'no'`,
     {
       code: `
 function test<T extends object>(t: T) {
-  return t ? 'yes' : 'no'
-}`,
+  return t ? 'yes' : 'no';
+}
+      `,
       errors: [ruleError(3, 10, 'alwaysTruthy')],
     },
     {
       code: `
 function test<T extends false>(t: T) {
-  return t ? 'yes' : 'no'
-}`,
+  return t ? 'yes' : 'no';
+}
+      `,
       errors: [ruleError(3, 10, 'alwaysFalsy')],
     },
     {
       code: `
 function test<T extends 'a' | 'b'>(t: T) {
-  return t ? 'yes' : 'no'
-}`,
+  return t ? 'yes' : 'no';
+}
+      `,
       errors: [ruleError(3, 10, 'alwaysTruthy')],
     },
 
     // Boolean expressions
     {
       code: `
-function test(a: "a") {
-  return a === "a"
-}`,
+function test(a: 'a') {
+  return a === 'a';
+}
+      `,
       errors: [ruleError(3, 10, 'literalBooleanExpression')],
     },
     {
       code: `
 const y = 1;
-if (y === 0) {}
-`,
+if (y === 0) {
+}
+      `,
       errors: [ruleError(3, 5, 'literalBooleanExpression')],
     },
     {
       code: `
 enum Foo {
   a = 1,
-  b = 2
+  b = 2,
 }
 
 const x = Foo.a;
-if (x === Foo.a) {}
-`,
+if (x === Foo.a) {
+}
+      `,
       errors: [ruleError(8, 5, 'literalBooleanExpression')],
     },
     // Nullish coalescing operator
@@ -343,28 +375,32 @@ if (x === Foo.a) {}
       code: `
 function test(a: string) {
   return a ?? 'default';
-}`,
+}
+      `,
       errors: [ruleError(3, 10, 'neverNullish')],
     },
     {
       code: `
 function test(a: string | false) {
   return a ?? 'default';
-}`,
+}
+      `,
       errors: [ruleError(3, 10, 'neverNullish')],
     },
     {
       code: `
 function test(a: null) {
   return a ?? 'default';
-}`,
+}
+      `,
       errors: [ruleError(3, 10, 'alwaysNullish')],
     },
     {
       code: `
 function test(a: never) {
   return a ?? 'default';
-}`,
+}
+      `,
       errors: [ruleError(3, 10, 'never')],
     },
 
@@ -372,8 +408,10 @@ function test(a: never) {
     {
       options: [{ checkArrayPredicates: true }],
       code: `
-[1,3,5].filter(() => true);
-[1,2,3].find(() => { return false; });
+[1, 3, 5].filter(() => true);
+[1, 2, 3].find(() => {
+  return false;
+});
 
 // with non-literal array
 function nothing(x: string[]) {
@@ -387,13 +425,13 @@ function nothing2(x: readonly string[]) {
 function nothing3(x: [string, string]) {
   return x.filter(() => false);
 }
-`,
+      `,
       errors: [
-        ruleError(2, 22, 'alwaysTruthy'),
-        ruleError(3, 29, 'alwaysFalsy'),
-        ruleError(7, 25, 'alwaysFalsy'),
-        ruleError(11, 25, 'alwaysFalsy'),
-        ruleError(15, 25, 'alwaysFalsy'),
+        ruleError(2, 24, 'alwaysTruthy'),
+        ruleError(4, 10, 'alwaysFalsy'),
+        ruleError(9, 25, 'alwaysFalsy'),
+        ruleError(13, 25, 'alwaysFalsy'),
+        ruleError(17, 25, 'alwaysFalsy'),
       ],
     },
     // Indexing cases
@@ -402,30 +440,34 @@ function nothing3(x: [string, string]) {
       //  the potential for undefined in its types
       code: `
 declare const dict: Record<string, object>;
-if(dict["mightNotExist"]) {}
-`,
-      errors: [ruleError(3, 4, 'alwaysTruthy')],
+if (dict['mightNotExist']) {
+}
+      `,
+      errors: [ruleError(3, 5, 'alwaysTruthy')],
     },
     {
       // Should still check tuples when accessed with literal numbers, since they don't have
       //   unsound index signatures
       code: `
-const x = [{}] as [{foo: string}];
-if(x[0]) {}
-if(x[0]?.foo) {}
-`,
+const x = [{}] as [{ foo: string }];
+if (x[0]) {
+}
+if (x[0]?.foo) {
+}
+      `,
       errors: [
-        ruleError(3, 4, 'alwaysTruthy'),
-        ruleError(4, 8, 'neverOptionalChain'),
+        ruleError(3, 5, 'alwaysTruthy'),
+        ruleError(5, 9, 'neverOptionalChain'),
       ],
     },
     {
       // Shouldn't mistake this for an array indexing case
       code: `
 declare const arr: object[];
-if(arr.filter) {}
-`,
-      errors: [ruleError(3, 4, 'alwaysTruthy')],
+if (arr.filter) {
+}
+      `,
+      errors: [ruleError(3, 5, 'alwaysTruthy')],
     },
     {
       options: [{ checkArrayPredicates: true }],
@@ -434,12 +476,12 @@ function truthy() {
   return [];
 }
 function falsy() {}
-[1,3,5].filter(truthy);
-[1,2,3].find(falsy);
-`,
+[1, 3, 5].filter(truthy);
+[1, 2, 3].find(falsy);
+      `,
       errors: [
-        ruleError(6, 16, 'alwaysTruthyFunc'),
-        ruleError(7, 14, 'alwaysFalsyFunc'),
+        ruleError(6, 18, 'alwaysTruthyFunc'),
+        ruleError(7, 16, 'alwaysFalsyFunc'),
       ],
     },
     // Supports generics
@@ -464,34 +506,38 @@ const b1 = true;
 const b2 = false;
 const t1 = b1 && b2;
 const t2 = b1 || b2;
-if(b1 && b2) {}
-while(b1 && b2) {}
-for (let i = 0; (b1 && b2); i++) { break; }
-const t1 = (b1 && b2) ? 'yes' : 'no'`,
+if (b1 && b2) {
+}
+while (b1 && b2) {}
+for (let i = 0; b1 && b2; i++) {
+  break;
+}
+const t1 = b1 && b2 ? 'yes' : 'no';
+      `,
       errors: [
         ruleError(4, 12, 'alwaysTruthy'),
         ruleError(5, 12, 'alwaysTruthy'),
-        ruleError(6, 4, 'alwaysTruthy'),
-        ruleError(7, 7, 'alwaysTruthy'),
-        ruleError(8, 18, 'alwaysTruthy'),
-        ruleError(9, 13, 'alwaysTruthy'),
+        ruleError(6, 5, 'alwaysTruthy'),
+        ruleError(8, 8, 'alwaysTruthy'),
+        ruleError(9, 17, 'alwaysTruthy'),
+        ruleError(12, 12, 'alwaysTruthy'),
       ],
     },
     {
       code: `
-while(true) {}
-for (;true;) {}
-do {} while(true)
+while (true) {}
+for (; true; ) {}
+do {} while (true);
       `,
       options: [{ allowConstantLoopConditions: false }],
       errors: [
-        ruleError(2, 7, 'alwaysTruthy'),
-        ruleError(3, 7, 'alwaysTruthy'),
-        ruleError(4, 13, 'alwaysTruthy'),
+        ruleError(2, 8, 'alwaysTruthy'),
+        ruleError(3, 8, 'alwaysTruthy'),
+        ruleError(4, 14, 'alwaysTruthy'),
       ],
     },
     {
-      code: `
+      code: noFormat`
 let foo = { bar: true };
 foo?.bar;
 foo ?. bar;
@@ -499,8 +545,8 @@ foo ?.
   bar;
 foo
   ?. bar;
-`,
-      output: `
+      `,
+      output: noFormat`
 let foo = { bar: true };
 foo.bar;
 foo . bar;
@@ -508,7 +554,7 @@ foo .
   bar;
 foo
   . bar;
-`,
+      `,
       errors: [
         {
           messageId: 'neverOptionalChain',
@@ -541,7 +587,7 @@ foo
       ],
     },
     {
-      code: `
+      code: noFormat`
 let foo = () => {};
 foo?.();
 foo ?. ();
@@ -549,7 +595,7 @@ foo ?.
   ();
 foo
   ?. ();
-`,
+      `,
       output: `
 let foo = () => {};
 foo();
@@ -558,7 +604,7 @@ foo${' '}
   ();
 foo
    ();
-`,
+      `,
       errors: [
         {
           messageId: 'neverOptionalChain',
@@ -591,7 +637,7 @@ foo
       ],
     },
     {
-      code: `
+      code: noFormat`
 let foo = () => {};
 foo?.(bar);
 foo ?. (bar);
@@ -599,7 +645,7 @@ foo ?.
   (bar);
 foo
   ?. (bar);
-`,
+      `,
       output: `
 let foo = () => {};
 foo(bar);
@@ -608,7 +654,7 @@ foo${' '}
   (bar);
 foo
    (bar);
-`,
+      `,
       errors: [
         {
           messageId: 'neverOptionalChain',
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
index 68e0e258383..a03cdc7d747 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-qualifier.test.ts
@@ -24,29 +24,33 @@ namespace X {
 
 namespace Y {
   export const x: X.T = 3;
-}`,
+}
+    `,
     `
 enum A {
-    X,
-    Y
+  X,
+  Y,
 }
 
 enum B {
-    Z = A.X
-}`,
+  Z = A.X,
+}
+    `,
     `
 namespace X {
-    export type T = number;
-    namespace Y {
-        type T = string;
-        const x: X.T = 0;
-    }
-}`,
-    `const x: A.B = 3;`,
+  export type T = number;
+  namespace Y {
+    type T = string;
+    const x: X.T = 0;
+  }
+}
+    `,
+    'const x: A.B = 3;',
     `
 namespace X {
   const z = X.y;
-}`,
+}
+    `,
   ],
 
   invalid: [
@@ -55,7 +59,8 @@ namespace X {
 namespace A {
   export type B = number;
   const x: A.B = 3;
-}`,
+}
+      `,
       errors: [
         {
           messageId,
@@ -66,14 +71,16 @@ namespace A {
 namespace A {
   export type B = number;
   const x: B = 3;
-}`,
+}
+      `,
     },
     {
       code: `
 namespace A {
   export const x = 3;
   export const y = A.x;
-}`,
+}
+      `,
       errors: [
         {
           messageId,
@@ -84,7 +91,8 @@ namespace A {
 namespace A {
   export const x = 3;
   export const y = x;
-}`,
+}
+      `,
     },
     {
       code: `
@@ -93,7 +101,8 @@ namespace A {
   export namespace B {
     const x: A.T = 3;
   }
-}`,
+}
+      `,
       errors: [
         {
           messageId,
@@ -106,7 +115,8 @@ namespace A {
   export namespace B {
     const x: T = 3;
   }
-}`,
+}
+      `,
     },
     {
       code: `
@@ -115,7 +125,8 @@ namespace A {
     export type T = number;
     const x: A.B.T = 3;
   }
-}`,
+}
+      `,
       errors: [
         {
           messageId,
@@ -128,7 +139,8 @@ namespace A {
     export type T = number;
     const x: T = 3;
   }
-}`,
+}
+      `,
     },
     {
       code: `
@@ -137,7 +149,8 @@ namespace A {
     export const x = 3;
     const y = A.B.x;
   }
-}`,
+}
+      `,
       errors: [
         {
           messageId,
@@ -150,14 +163,16 @@ namespace A {
     export const x = 3;
     const y = x;
   }
-}`,
+}
+      `,
     },
     {
       code: `
 enum A {
   B,
-  C = A.B
-}`,
+  C = A.B,
+}
+      `,
       errors: [
         {
           messageId,
@@ -167,17 +182,19 @@ enum A {
       output: `
 enum A {
   B,
-  C = B
-}`,
+  C = B,
+}
+      `,
     },
     {
       code: `
 namespace Foo {
   export enum A {
     B,
-    C = Foo.A.B
+    C = Foo.A.B,
   }
-}`,
+}
+      `,
       errors: [
         {
           messageId,
@@ -188,16 +205,18 @@ namespace Foo {
 namespace Foo {
   export enum A {
     B,
-    C = B
+    C = B,
   }
-}`,
+}
+      `,
     },
     {
       code: `
 import * as Foo from './foo';
 declare module './foo' {
   const x: Foo.T = 3;
-}`,
+}
+      `,
       errors: [
         {
           messageId,
@@ -208,7 +227,8 @@ declare module './foo' {
 import * as Foo from './foo';
 declare module './foo' {
   const x: T = 3;
-}`,
+}
+      `,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-type-arguments.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-type-arguments.test.ts
index 11ff8344698..9c642d5f88f 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-type-arguments.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-type-arguments.test.ts
@@ -14,187 +14,281 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-unnecessary-type-arguments', rule, {
   valid: [
-    `f<>();`,
-    `f<string>();`,
-    `expect().toBe<>();`,
-    `class Foo extends Bar<> {}`,
-    `class Foo extends Bar<string> {}`,
-    `class Foo implements Bar<> {}`,
-    `class Foo implements Bar<string> {}`,
-    `function f<T = number>() { }
-      f();`,
-    `function f<T = number>() { }
-      f<string>();`,
-    `declare const f: (<T = number>() => void) | null;
-      f?.();`,
-    `declare const f: (<T = number>() => void) | null;
-      f?.<string>();`,
-    `declare const f: any;
-      f();`,
-    `declare const f: any;
-      f<string>();`,
-    `declare const f: unknown;
-      f();`,
-    `declare const f: unknown;
-      f<string>();`,
-    `function g<T = number, U = string>() { }
-      g<number, number>();`,
-    `declare const g: any;
-      g<string, string>();`,
-    `declare const g: unknown;
-      g<string, string>();`,
-    `class C<T = number> { }
-      new C<string>();`,
-    `declare const C: any;
-      new C<string>();`,
-    `declare const C: unknown;
-      new C<string>();`,
-    `class C<T = number> { }
-      class D extends C<string> { }`,
-    `declare const C: any;
-      class D extends C<string> { }`,
-    `declare const C: unknown;
-      class D extends C<string> { }`,
-    `interface I<T = number> { }
-      class Impl implements I<string> { }`,
-    `class C<TC = number> { }
-      class D<TD = number> extends C { }`,
-    `declare const C: any;
-      class D<TD = number> extends C { }`,
-    `declare const C: unknown;
-      class D<TD = number> extends C { }`,
-    `let a: A<number>`,
-    `class Foo<T> {}
-      const foo = new Foo<number>();`,
-    `type Foo<T> = import('foo').Foo<T>;`,
-    `class Bar<T = number> {}
-      class Foo<T = number> extends Bar<T> {}`,
-    `interface Bar<T = number> {}
-      class Foo<T = number> implements Bar<T> {}`,
-    `class Bar<T = number> {}
-      class Foo<T = number> extends Bar<string> {}`,
-    `interface Bar<T = number> {}
-      class Foo<T = number> implements Bar<string> {}`,
-    `import { F } from './missing';
-      function bar<T = F>() {}
-      bar<F<number>>()`,
+    'f<>();',
+    'f<string>();',
+    'expect().toBe<>();',
+    'class Foo extends Bar<> {}',
+    'class Foo extends Bar<string> {}',
+    'class Foo implements Bar<> {}',
+    'class Foo implements Bar<string> {}',
+    `
+function f<T = number>() {}
+f();
+    `,
+    `
+function f<T = number>() {}
+f<string>();
+    `,
+    `
+declare const f: (<T = number>() => void) | null;
+f?.();
+    `,
+    `
+declare const f: (<T = number>() => void) | null;
+f?.<string>();
+    `,
+    `
+declare const f: any;
+f();
+    `,
+    `
+declare const f: any;
+f<string>();
+    `,
+    `
+declare const f: unknown;
+f();
+    `,
+    `
+declare const f: unknown;
+f<string>();
+    `,
+    `
+function g<T = number, U = string>() {}
+g<number, number>();
+    `,
+    `
+declare const g: any;
+g<string, string>();
+    `,
+    `
+declare const g: unknown;
+g<string, string>();
+    `,
+    `
+class C<T = number> {}
+new C<string>();
+    `,
+    `
+declare const C: any;
+new C<string>();
+    `,
+    `
+declare const C: unknown;
+new C<string>();
+    `,
+    `
+class C<T = number> {}
+class D extends C<string> {}
+    `,
+    `
+declare const C: any;
+class D extends C<string> {}
+    `,
+    `
+declare const C: unknown;
+class D extends C<string> {}
+    `,
+    `
+interface I<T = number> {}
+class Impl implements I<string> {}
+    `,
+    `
+class C<TC = number> {}
+class D<TD = number> extends C {}
+    `,
+    `
+declare const C: any;
+class D<TD = number> extends C {}
+    `,
+    `
+declare const C: unknown;
+class D<TD = number> extends C {}
+    `,
+    'let a: A<number>;',
+    `
+class Foo<T> {}
+const foo = new Foo<number>();
+    `,
+    "type Foo<T> = import('foo').Foo<T>;",
+    `
+class Bar<T = number> {}
+class Foo<T = number> extends Bar<T> {}
+    `,
+    `
+interface Bar<T = number> {}
+class Foo<T = number> implements Bar<T> {}
+    `,
+    `
+class Bar<T = number> {}
+class Foo<T = number> extends Bar<string> {}
+    `,
+    `
+interface Bar<T = number> {}
+class Foo<T = number> implements Bar<string> {}
+    `,
+    `
+import { F } from './missing';
+function bar<T = F>() {}
+bar<F<number>>();
+    `,
   ],
   invalid: [
     {
-      code: `function f<T = number>() { }
-        f<number>();`,
+      code: `
+function f<T = number>() {}
+f<number>();
+      `,
       errors: [
         {
-          column: 11,
+          column: 3,
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `function f<T = number>() { }
-        f();`,
+      output: `
+function f<T = number>() {}
+f();
+      `,
     },
     {
-      code: `function g<T = number, U = string>() { }
-        g<string, string>();`,
+      code: `
+function g<T = number, U = string>() {}
+g<string, string>();
+      `,
       errors: [
         {
-          column: 19,
+          column: 11,
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `function g<T = number, U = string>() { }
-        g<string>();`,
+      output: `
+function g<T = number, U = string>() {}
+g<string>();
+      `,
     },
     {
-      code: `class C<T = number> { }
-        function h(c: C<number>) { }`,
+      code: `
+class C<T = number> {}
+function h(c: C<number>) {}
+      `,
       errors: [
         {
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `class C<T = number> { }
-        function h(c: C) { }`,
+      output: `
+class C<T = number> {}
+function h(c: C) {}
+      `,
     },
     {
-      code: `class C<T = number> { }
-        new C<number>();`,
+      code: `
+class C<T = number> {}
+new C<number>();
+      `,
       errors: [
         {
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `class C<T = number> { }
-        new C();`,
+      output: `
+class C<T = number> {}
+new C();
+      `,
     },
     {
-      code: `class C<T = number> { }
-        class D extends C<number> { }`,
+      code: `
+class C<T = number> {}
+class D extends C<number> {}
+      `,
       errors: [
         {
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `class C<T = number> { }
-        class D extends C { }`,
+      output: `
+class C<T = number> {}
+class D extends C {}
+      `,
     },
     {
-      code: `interface I<T = number> { }
-        class Impl implements I<number> { }`,
+      code: `
+interface I<T = number> {}
+class Impl implements I<number> {}
+      `,
       errors: [
         {
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `interface I<T = number> { }
-        class Impl implements I { }`,
+      output: `
+interface I<T = number> {}
+class Impl implements I {}
+      `,
     },
     {
-      code: `class Foo<T = number> {}
-        const foo = new Foo<number>();`,
+      code: `
+class Foo<T = number> {}
+const foo = new Foo<number>();
+      `,
       errors: [
         {
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `class Foo<T = number> {}
-        const foo = new Foo();`,
+      output: `
+class Foo<T = number> {}
+const foo = new Foo();
+      `,
     },
     {
-      code: `interface Bar<T = string> {}
-        class Foo<T = number> implements Bar<string> {}`,
+      code: `
+interface Bar<T = string> {}
+class Foo<T = number> implements Bar<string> {}
+      `,
       errors: [
         {
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `interface Bar<T = string> {}
-        class Foo<T = number> implements Bar {}`,
+      output: `
+interface Bar<T = string> {}
+class Foo<T = number> implements Bar {}
+      `,
     },
     {
-      code: `class Bar<T = string> {}
-        class Foo<T = number> extends Bar<string> {}`,
+      code: `
+class Bar<T = string> {}
+class Foo<T = number> extends Bar<string> {}
+      `,
       errors: [
         {
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `class Bar<T = string> {}
-        class Foo<T = number> extends Bar {}`,
+      output: `
+class Bar<T = string> {}
+class Foo<T = number> extends Bar {}
+      `,
     },
     {
-      code: `import { F } from './missing';
-        function bar<T = F<string>>() {}
-        bar<F<string>>()`,
+      code: `
+import { F } from './missing';
+function bar<T = F<string>>() {}
+bar<F<string>>();
+      `,
       errors: [
         {
-          line: 3,
-          column: 13,
+          line: 4,
+          column: 5,
           messageId: 'unnecessaryTypeParameter',
         },
       ],
-      output: `import { F } from './missing';
-        function bar<T = F<string>>() {}
-        bar()`,
+      output: `
+import { F } from './missing';
+function bar<T = F<string>>() {}
+bar();
+      `,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts
index 4d1ae880e84..d6febe39ea5 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts
@@ -15,27 +15,34 @@ const ruleTester = new RuleTester({
 ruleTester.run('no-unnecessary-type-assertion', rule, {
   valid: [
     'const foo = 3 as number;',
-    'const foo = <number> 3;',
+    'const foo = <number>3;',
     'const foo = <3>3;',
     'const foo = 3 as 3;',
     `
-type Tuple = [3, "hi", "bye"];
-const foo = ([3, "hi", "bye"]) as Tuple;`,
+type Tuple = [3, 'hi', 'bye'];
+const foo = [3, 'hi', 'bye'] as Tuple;
+    `,
     `
 type PossibleTuple = {};
-const foo = ({}) as PossibleTuple;`,
+const foo = {} as PossibleTuple;
+    `,
     `
-type PossibleTuple = { hello: "hello" };
-const foo = ({ hello: "hello" }) as PossibleTuple;`,
+type PossibleTuple = { hello: 'hello' };
+const foo = { hello: 'hello' } as PossibleTuple;
+    `,
+    `
+type PossibleTuple = { 0: 'hello'; 5: 'hello' };
+const foo = { 0: 'hello', 5: 'hello' } as PossibleTuple;
+    `,
     `
-type PossibleTuple = { 0: "hello", 5: "hello" };
-const foo = ({ 0: "hello", 5: "hello" }) as PossibleTuple;`,
-    `let bar: number | undefined = x;
-      let foo: number = bar!;`,
+let bar: number | undefined = x;
+let foo: number = bar!;
+    `,
     {
       code: `
 type Foo = number;
-const foo = (3 + 5) as Foo;`,
+const foo = (3 + 5) as Foo;
+      `,
       options: [{ typesToIgnore: ['Foo'] }],
     },
     {
@@ -43,7 +50,7 @@ const foo = (3 + 5) as Foo;`,
       options: [{ typesToIgnore: ['any'] }],
     },
     {
-      code: "((Syntax as any).ArrayExpression = 'foo')",
+      code: "(Syntax as any).ArrayExpression = 'foo';",
       options: [{ typesToIgnore: ['any'] }],
     },
     {
@@ -53,26 +60,27 @@ const foo = (3 + 5) as Foo;`,
     {
       code: `
 type Foo = number;
-const foo = <Foo>(3 + 5);`,
+const foo = <Foo>(3 + 5);
+      `,
       options: [{ typesToIgnore: ['Foo'] }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/453
     // the ol' use-before-assign-is-okay-trust-me assertion
     `
-let bar: number
-bar! + 1
+let bar: number;
+bar! + 1;
     `,
     `
-let bar: undefined | number
-bar! + 1
+let bar: undefined | number;
+bar! + 1;
     `,
     `
-let bar: number, baz: number
-bar! + 1
+let bar: number, baz: number;
+bar! + 1;
     `,
     `
 function foo<T extends string | undefined>(bar: T) {
-  return bar!
+  return bar!;
 }
     `,
     `
@@ -108,23 +116,29 @@ class Mx {
     `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/1199
     `
-function testFunction(_param: string | undefined): void { /* noop */ }
-const value = 'test' as string | null | undefined
-testFunction(value!)
+function testFunction(_param: string | undefined): void {
+  /* noop */
+}
+const value = 'test' as string | null | undefined;
+testFunction(value!);
     `,
     `
-function testFunction(_param: string | null): void { /* noop */ }
-const value = 'test' as string | null | undefined
-testFunction(value!)
+function testFunction(_param: string | null): void {
+  /* noop */
+}
+const value = 'test' as string | null | undefined;
+testFunction(value!);
     `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/982
     {
       code: `
-declare namespace JSX { interface IntrinsicElements { div: { key?: string | number } } }
+declare namespace JSX {
+  interface IntrinsicElements {
+    div: { key?: string | number };
+  }
+}
 
-function Test(props: {
-  id?: null | string | number;
-}) {
+function Test(props: { id?: null | string | number }) {
   return <div key={props.id!} />;
 }
       `,
@@ -138,13 +152,13 @@ const c = [...a, ...b] as const;
       `,
     },
     {
-      code: `const a = [1, 2] as const;`,
+      code: 'const a = [1, 2] as const;',
     },
     {
-      code: `const a = 'a' as const;`,
+      code: "const a = 'a' as const;",
     },
     {
-      code: `const a = { foo: 'foo' } as const`,
+      code: "const a = { foo: 'foo' } as const;",
     },
     {
       code: `
@@ -154,13 +168,13 @@ const c = <const>[...a, ...b];
       `,
     },
     {
-      code: `const a = <const>[1, 2];`,
+      code: 'const a = <const>[1, 2];',
     },
     {
-      code: `const a = <const>'a';`,
+      code: "const a = <const>'a';",
     },
     {
-      code: `const a = <const>{ foo: 'foo' };`,
+      code: "const a = <const>{ foo: 'foo' };",
     },
   ],
 
@@ -168,7 +182,8 @@ const c = <const>[...a, ...b];
     {
       code: `
 const foo = 3;
-const bar = foo!;`,
+const bar = foo!;
+      `,
       errors: [
         {
           messageId: 'unnecessaryAssertion',
@@ -179,7 +194,8 @@ const bar = foo!;`,
     },
     {
       code: `
-const foo = (3 + 5) as number;`,
+const foo = (3 + 5) as number;
+      `,
       errors: [
         {
           messageId: 'unnecessaryAssertion',
@@ -190,7 +206,8 @@ const foo = (3 + 5) as number;`,
     },
     {
       code: `
-const foo = <number>(3 + 5);`,
+const foo = <number>(3 + 5);
+      `,
       errors: [
         {
           messageId: 'unnecessaryAssertion',
@@ -202,7 +219,8 @@ const foo = <number>(3 + 5);`,
     {
       code: `
 type Foo = number;
-const foo = (3 + 5) as Foo;`,
+const foo = (3 + 5) as Foo;
+      `,
       errors: [
         {
           messageId: 'unnecessaryAssertion',
@@ -214,7 +232,8 @@ const foo = (3 + 5) as Foo;`,
     {
       code: `
 type Foo = number;
-const foo = <Foo>(3 + 5);`,
+const foo = <Foo>(3 + 5);
+      `,
       errors: [
         {
           messageId: 'unnecessaryAssertion',
@@ -226,12 +245,12 @@ const foo = <Foo>(3 + 5);`,
     // https://github.com/typescript-eslint/typescript-eslint/issues/453
     {
       code: `
-let bar: number = 1
-bar! + 1
+let bar: number = 1;
+bar! + 1;
       `,
       output: `
-let bar: number = 1
-bar + 1
+let bar: number = 1;
+bar + 1;
       `,
       errors: [
         {
@@ -243,12 +262,12 @@ bar + 1
     {
       // definite declaration operator
       code: `
-let bar!: number
-bar! + 1
+let bar!: number;
+bar! + 1;
       `,
       output: `
-let bar!: number
-bar + 1
+let bar!: number;
+bar + 1;
       `,
       errors: [
         {
@@ -259,14 +278,14 @@ bar + 1
     },
     {
       code: `
-let bar: number | undefined
+let bar: number | undefined;
 bar = 1;
-bar! + 1
+bar! + 1;
       `,
       output: `
-let bar: number | undefined
+let bar: number | undefined;
 bar = 1;
-bar + 1
+bar + 1;
       `,
       errors: [
         {
@@ -278,12 +297,12 @@ bar + 1
     {
       code: `
 function foo<T extends string>(bar: T) {
-  return bar!
+  return bar!;
 }
       `,
       output: `
 function foo<T extends string>(bar: T) {
-  return bar
+  return bar;
 }
       `,
       errors: [
@@ -375,27 +394,31 @@ class Mx {
     // https://github.com/typescript-eslint/typescript-eslint/issues/982
     {
       code: `
-declare namespace JSX { interface IntrinsicElements { div: { key?: string | number } } }
+declare namespace JSX {
+  interface IntrinsicElements {
+    div: { key?: string | number };
+  }
+}
 
-function Test(props: {
-  id?: string | number;
-}) {
+function Test(props: { id?: string | number }) {
   return <div key={props.id!} />;
 }
       `,
       output: `
-declare namespace JSX { interface IntrinsicElements { div: { key?: string | number } } }
+declare namespace JSX {
+  interface IntrinsicElements {
+    div: { key?: string | number };
+  }
+}
 
-function Test(props: {
-  id?: string | number;
-}) {
+function Test(props: { id?: string | number }) {
   return <div key={props.id} />;
 }
       `,
       errors: [
         {
           messageId: 'contextuallyUnnecessary',
-          line: 7,
+          line: 9,
         },
       ],
       filename: 'react.tsx',
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
index bc7b6c7d086..8adb44b9960 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-call.test.ts
@@ -3,6 +3,7 @@ import {
   RuleTester,
   batchedSingleLineTests,
   getFixturesRootDir,
+  noFormat,
 } from '../RuleTester';
 
 const ruleTester = new RuleTester({
@@ -15,12 +16,24 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-unsafe-call', rule, {
   valid: [
-    'function foo(x: () => void) { x() }',
-    'function foo(x?: { a: () => void }) { x?.a() }',
-    'function foo(x: { a?: () => void }) { x.a?.() }',
-    'new Map()',
-    'String.raw`foo`',
-    'const x = import("./foo");',
+    `
+function foo(x: () => void) {
+  x();
+}
+    `,
+    `
+function foo(x?: { a: () => void }) {
+  x?.a();
+}
+    `,
+    `
+function foo(x: { a?: () => void }) {
+  x.a?.();
+}
+    `,
+    'new Map();',
+    'String.raw`foo`;',
+    "const x = import('./foo');",
     // https://github.com/typescript-eslint/typescript-eslint/issues/1825
     `
       let foo: any = 23;
@@ -29,7 +42,7 @@ ruleTester.run('no-unsafe-call', rule, {
   ],
   invalid: [
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(x: any) { x() }
 function foo(x: any) { x?.() }
 function foo(x: any) { x.a.b.c.d.e.f.g() }
@@ -63,7 +76,7 @@ function foo(x: any) { x.a.b.c.d.e.f.g?.() }
       ],
     }),
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(x: { a: any }) { x.a() }
 function foo(x: { a: any }) { x?.a() }
 function foo(x: { a: any }) { x.a?.() }
@@ -90,7 +103,7 @@ function foo(x: { a: any }) { x.a?.() }
       ],
     }),
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(x: any) { new x() }
 function foo(x: { a: any }) { new x.a() }
       `,
@@ -110,7 +123,7 @@ function foo(x: { a: any }) { new x.a() }
       ],
     }),
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(x: any) { x\`foo\` }
 function foo(x: { tag: any }) { x.tag\`foo\` }
       `,
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-member-access.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-member-access.test.ts
index 484d4690c16..bf6ff85c121 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-member-access.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-member-access.test.ts
@@ -3,6 +3,7 @@ import {
   RuleTester,
   batchedSingleLineTests,
   getFixturesRootDir,
+  noFormat,
 } from '../RuleTester';
 
 const ruleTester = new RuleTester({
@@ -15,20 +16,60 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-unsafe-member-access', rule, {
   valid: [
-    'function foo(x: { a: number }, y: any) { x[y++] }',
-    'function foo(x: { a: number }) { x.a }',
-    'function foo(x?: { a: number }) { x?.a }',
-    'function foo(x: { a: number }) { x["a"] }',
-    'function foo(x?: { a: number }) { x?.["a"] }',
-    'function foo(x: { a: number }, y: string) { x[y] }',
-    'function foo(x?: { a: number }, y: string) { x?.[y] }',
-    'function foo(x: string[]) { x[1] }',
-    'function foo(x?: string[]) { x?.[1++] }',
-    'function foo(x?: string[]) { x?.[(1 as any)++] }',
+    `
+function foo(x: { a: number }, y: any) {
+  x[y++];
+}
+    `,
+    `
+function foo(x: { a: number }) {
+  x.a;
+}
+    `,
+    `
+function foo(x?: { a: number }) {
+  x?.a;
+}
+    `,
+    `
+function foo(x: { a: number }) {
+  x['a'];
+}
+    `,
+    `
+function foo(x?: { a: number }) {
+  x?.['a'];
+}
+    `,
+    `
+function foo(x: { a: number }, y: string) {
+  x[y];
+}
+    `,
+    `
+function foo(x?: { a: number }, y: string) {
+  x?.[y];
+}
+    `,
+    `
+function foo(x: string[]) {
+  x[1];
+}
+    `,
+    `
+function foo(x?: string[]) {
+  x?.[1++];
+}
+    `,
+    `
+function foo(x?: string[]) {
+  x?.[(1 as any)++];
+}
+    `,
   ],
   invalid: [
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(x: any) { x.a }
 function foo(x: any) { x.a.b.c.d.e.f.g }
 function foo(x: { a: any }) { x.a.b.c.d.e.f.g }
@@ -64,7 +105,7 @@ function foo(x: { a: any }) { x.a.b.c.d.e.f.g }
       ],
     }),
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(x: any) { x['a'] }
 function foo(x: any) { x['a']['b']['c'] }
       `,
@@ -90,7 +131,7 @@ function foo(x: any) { x['a']['b']['c'] }
       ],
     }),
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(x: { a: number }, y: any) { x[y] }
 function foo(x?: { a: number }, y: any) { x?.[y] }
 function foo(x: { a: number }, y: any) { x[y += 1] }
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
index 0fdcaddf36b..b0c1ead9007 100644
--- a/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-return.test.ts
@@ -3,6 +3,7 @@ import {
   RuleTester,
   batchedSingleLineTests,
   getFixturesRootDir,
+  noFormat,
 } from '../RuleTester';
 
 const ruleTester = new RuleTester({
@@ -15,29 +16,65 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('no-unsafe-return', rule, {
   valid: [
-    'function foo() { return; }',
-    'function foo() { return 1; }',
-    'function foo() { return ""; }',
-    'function foo() { return true; }',
+    `
+function foo() {
+  return;
+}
+    `,
+    `
+function foo() {
+  return 1;
+}
+    `,
+    `
+function foo() {
+  return '';
+}
+    `,
+    `
+function foo() {
+  return true;
+}
+    `,
     // this actually types as `never[]`
-    'function foo() { return []; }',
+    `
+function foo() {
+  return [];
+}
+    `,
     // explicit any generic return type is allowed, if you want to be unsafe like that
-    'function foo(): Set<any> { return new Set<any>(); }',
+    `
+function foo(): Set<any> {
+  return new Set<any>();
+}
+    `,
     // TODO - this should error, but it's hard to detect, as the type references are different
-    'function foo(): ReadonlySet<number> { return new Set<any>(); }',
-    'function foo(): Set<number> { return new Set([1]); }',
+    `
+function foo(): ReadonlySet<number> {
+  return new Set<any>();
+}
+    `,
+    `
+function foo(): Set<number> {
+  return new Set([1]);
+}
+    `,
     `
       type Foo<T = number> = { prop: T };
-      function foo(): Foo { return ({ prop: 1 } as Foo<number>)}
+      function foo(): Foo {
+        return { prop: 1 } as Foo<number>;
+      }
     `,
     `
       type Foo = { prop: any };
-      function foo(): Foo { return { prop: '' } as Foo; }
+      function foo(): Foo {
+        return { prop: '' } as Foo;
+      }
     `,
   ],
   invalid: [
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo() { return (1 as any); }
 function foo() { return Object.create(null); }
 const foo = () => { return (1 as any) };
@@ -79,7 +116,7 @@ const foo = () => Object.create(null);
       ],
     }),
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo() { return ([] as any[]); }
 function foo() { return ([] as Array<any>); }
 function foo() { return ([] as readonly any[]); }
@@ -139,7 +176,7 @@ const foo = () => ([] as any[]);
       ],
     }),
     ...batchedSingleLineTests({
-      code: `
+      code: noFormat`
 function foo(): Set<string> { return new Set<any>(); }
 function foo(): Map<string, string> { return new Map<string, any>(); }
 function foo(): Set<string[]> { return new Set<any[]>(); }
@@ -182,9 +219,11 @@ function foo(): Set<Set<Set<string>>> { return new Set<Set<Set<any>>>(); }
     }),
     {
       code: `
-        type Fn = () => Set<string>;
-        const foo1: Fn = () => new Set<any>();
-        const foo2: Fn = function test() { return new Set<any>() };
+type Fn = () => Set<string>;
+const foo1: Fn = () => new Set<any>();
+const foo2: Fn = function test() {
+  return new Set<any>();
+};
       `,
       errors: [
         {
@@ -197,7 +236,7 @@ function foo(): Set<Set<Set<string>>> { return new Set<Set<Set<any>>>(); }
         },
         {
           messageId: 'unsafeReturnAssignment',
-          line: 4,
+          line: 5,
           data: {
             sender: 'Set<any>',
             receiver: 'Set<string>',
@@ -207,10 +246,12 @@ function foo(): Set<Set<Set<string>>> { return new Set<Set<Set<any>>>(); }
     },
     {
       code: `
-        type Fn = () => Set<string>;
-        function receiver(arg: Fn) {}
-        receiver(() => new Set<any>());
-        receiver(function test() { return new Set<any>() });
+type Fn = () => Set<string>;
+function receiver(arg: Fn) {}
+receiver(() => new Set<any>());
+receiver(function test() {
+  return new Set<any>();
+});
       `,
       errors: [
         {
@@ -223,7 +264,7 @@ function foo(): Set<Set<Set<string>>> { return new Set<Set<Set<any>>>(); }
         },
         {
           messageId: 'unsafeReturnAssignment',
-          line: 5,
+          line: 6,
           data: {
             sender: 'Set<any>',
             receiver: 'Set<string>',
diff --git a/packages/eslint-plugin/tests/rules/no-untyped-public-signature.test.ts b/packages/eslint-plugin/tests/rules/no-untyped-public-signature.test.ts
index 28ee928cb41..d71b98ce3c1 100644
--- a/packages/eslint-plugin/tests/rules/no-untyped-public-signature.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-untyped-public-signature.test.ts
@@ -13,71 +13,65 @@ const ruleTester = new RuleTester({
 ruleTester.run('no-untyped-public-signature', rule, {
   valid: [
     {
-      code: `class A {
-                  private a(c) {
-                  }
-                }`,
+      code: `
+class A {
+  private a(c) {}
+}
+      `,
     },
     {
-      code: `class A {
-                  private async a(c) {
-                  }
-                }`,
+      code: `
+class A {
+  private async a(c) {}
+}
+      `,
     },
     {
       code: `
-            class A {
-                public b(c: string):void {
-
-                }
-            }`,
+class A {
+  public b(c: string): void {}
+}
+      `,
     },
     {
       code: `
-             class A {
-                public b(...c):void {
-
-                }
-            }`,
+class A {
+  public b(...c): void {}
+}
+      `,
     },
     {
       code: `
-             class A {
-                b(c):void {
-
-                }
-            }`,
+class A {
+  b(c): void {}
+}
+      `,
       options: [{ ignoredMethods: ['b'] }],
     },
     {
       code: `
-             class A {
-                ['b'](c):void {
-
-                }
-            }`,
+class A {
+  ['b'](c): void {}
+}
+      `,
       options: [{ ignoredMethods: ['b'] }],
     },
     {
       code: `
-             class A {
-                [\`b\`](c):void {
-
-                }
-            }`,
+class A {
+  [\`b\`](c): void {}
+}
+      `,
       options: [{ ignoredMethods: ['b'] }],
     },
     {
       code: `
-             class A {
-                b(...c):void {
+class A {
+  b(...c): void {}
 
-                }
-
-                d(c):void {
-
-                }
-            }`,
+  d(c): void {}
+}
+      `,
       options: [{ ignoredMethods: ['b', 'd'] }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/1229
@@ -133,54 +127,56 @@ class Foo {
   invalid: [
     //untyped parameter
     {
-      code: `class A {
-                public b(c):void {
-
-                }
-            }`,
+      code: `
+class A {
+  public b(c): void {}
+}
+      `,
       errors: [{ messageId: 'untypedParameter' }],
     },
     //untyped parameter (any)
     {
-      code: `class A {
-                public b(c: any):void {
-
-                }
-            }`,
+      code: `
+class A {
+  public b(c: any): void {}
+}
+      `,
       errors: [{ messageId: 'untypedParameter' }],
     },
     //implicit public method
     {
-      code: `class A {
-                b(c):void {
-
-                }
-            }`,
+      code: `
+class A {
+  b(c): void {}
+}
+      `,
       errors: [{ messageId: 'untypedParameter' }],
     },
     //implicit async public method
     {
-      code: `class A {
-                  async a(c): void {
-                  }
-                }`,
+      code: `
+class A {
+  async a(c): void {}
+}
+      `,
       errors: [{ messageId: 'untypedParameter' }],
     },
     //no return type
     {
-      code: `class A {
-                  public a(c: number) {
-                  }
-                }`,
+      code: `
+class A {
+  public a(c: number) {}
+}
+      `,
       errors: [{ messageId: 'noReturnType' }],
     },
     //no return type + untyped parameter
     {
-      code: `class A {
-                public b(c) {
-
-                }
-            }`,
+      code: `
+class A {
+  public b(c) {}
+}
+      `,
       errors: [
         { messageId: 'untypedParameter' },
         { messageId: 'noReturnType' },
@@ -188,71 +184,70 @@ class Foo {
     },
     //any return type
     {
-      code: `class A {
-                public b(c: number): any {
-
-                }
-            }`,
+      code: `
+class A {
+  public b(c: number): any {}
+}
+      `,
       errors: [{ messageId: 'noReturnType' }],
     },
     //with ignored methods
     {
-      code: `class A {
-                public b(c: number): any {
-
-                }
+      code: `
+class A {
+  public b(c: number): any {}
 
-                c() {
-                }
-            }`,
+  c() {}
+}
+      `,
       options: [{ ignoredMethods: ['c'] }],
       errors: [{ messageId: 'noReturnType' }],
     },
     {
       code: `
-          let c = 'd';
-          class A {
-                [methodName]() {
-                }
-            }`,
+let c = 'd';
+class A {
+  [methodName]() {}
+}
+      `,
       options: [{ ignoredMethods: ['methodName'] }],
       errors: [{ messageId: 'noReturnType' }],
     },
     {
       code: `
-          class A {
-                [1]() {
-                }
-            }`,
+class A {
+  [1]() {}
+}
+      `,
       options: [{ ignoredMethods: ['1'] }],
       errors: [{ messageId: 'noReturnType' }],
     },
     {
       code: `
-          let c = 'C';
-          class A {
-                [\`methodName\${c}\`]() {
-                }
-            }`,
+let c = 'C';
+class A {
+  [\`methodName\${c}\`]() {}
+}
+      `,
       options: [{ ignoredMethods: ['methodNameC', 'methodNamec'] }],
       errors: [{ messageId: 'noReturnType' }],
     },
     {
       code: `
-          let c = '1';
-          class A {
-                [(c as number)]() {
-                }
-            }`,
+let c = '1';
+class A {
+  [c as number]() {}
+}
+      `,
       options: [{ ignoredMethods: ['1'] }],
       errors: [{ messageId: 'noReturnType' }],
     },
     {
       code: `
-          class A {
-                abstract c() {
-                }
-            }`,
+class A {
+  abstract c() {}
+}
+      `,
       errors: [{ messageId: 'noReturnType' }],
     },
     // https://github.com/typescript-eslint/typescript-eslint/issues/1229
diff --git a/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts b/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
index feb3a584bcc..a50d74f6b74 100644
--- a/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unused-expressions.test.ts
@@ -69,19 +69,19 @@ ruleTester.run('no-unused-expressions', rule, {
   invalid: [
     {
       code: `
-if(0) 0
-        `,
+if (0) 0;
+      `,
       errors: error([
         {
           line: 2,
-          column: 7,
+          column: 8,
         },
       ]),
     },
     {
       code: `
-f(0), {}
-        `,
+f(0), {};
+      `,
       errors: error([
         {
           line: 2,
@@ -91,8 +91,8 @@ f(0), {}
     },
     {
       code: `
-a, b()
-        `,
+a, b();
+      `,
       errors: error([
         {
           line: 2,
@@ -102,8 +102,11 @@ a, b()
     },
     {
       code: `
-a() && function namedFunctionInExpressionContext () {f();}
-        `,
+a() &&
+  function namedFunctionInExpressionContext() {
+    f();
+  };
+      `,
       errors: error([
         {
           line: 2,
@@ -113,8 +116,8 @@ a() && function namedFunctionInExpressionContext () {f();}
     },
     {
       code: `
-a?.b
-        `,
+a?.b;
+      `,
       errors: error([
         {
           line: 2,
@@ -124,8 +127,8 @@ a?.b
     },
     {
       code: `
-(a?.b).c
-        `,
+(a?.b).c;
+      `,
       errors: error([
         {
           line: 2,
@@ -135,8 +138,8 @@ a?.b
     },
     {
       code: `
-a?.['b']
-        `,
+a?.['b'];
+      `,
       errors: error([
         {
           line: 2,
@@ -146,8 +149,8 @@ a?.['b']
     },
     {
       code: `
-(a?.['b']).c
-        `,
+(a?.['b']).c;
+      `,
       errors: error([
         {
           line: 2,
@@ -157,8 +160,8 @@ a?.['b']
     },
     {
       code: `
-a?.b()?.c
-        `,
+a?.b()?.c;
+      `,
       errors: error([
         {
           line: 2,
@@ -168,8 +171,8 @@ a?.b()?.c
     },
     {
       code: `
-(a?.b()).c
-        `,
+(a?.b()).c;
+      `,
       errors: error([
         {
           line: 2,
@@ -180,7 +183,7 @@ a?.b()?.c
     {
       code: `
 one[2]?.[3][4];
-        `,
+      `,
       errors: error([
         {
           line: 2,
@@ -191,7 +194,7 @@ one[2]?.[3][4];
     {
       code: `
 one.two?.three.four;
-        `,
+      `,
       errors: error([
         {
           line: 2,
diff --git a/packages/eslint-plugin/tests/rules/no-unused-vars.test.ts b/packages/eslint-plugin/tests/rules/no-unused-vars.test.ts
index 45bb8c80db1..f59cb588425 100644
--- a/packages/eslint-plugin/tests/rules/no-unused-vars.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unused-vars.test.ts
@@ -24,426 +24,439 @@ ruleTester.run('no-unused-vars', rule, {
 import { ClassDecoratorFactory } from 'decorators';
 @ClassDecoratorFactory()
 export class Foo {}
-        `,
+    `,
     `
 import { ClassDecorator } from 'decorators';
 @ClassDecorator
 export class Foo {}
-        `,
+    `,
     `
 import { AccessorDecoratorFactory } from 'decorators';
 export class Foo {
-    @AccessorDecoratorFactory(true)
-    get bar() {}
+  @AccessorDecoratorFactory(true)
+  get bar() {}
 }
-        `,
+    `,
     `
 import { AccessorDecorator } from 'decorators';
 export class Foo {
-    @AccessorDecorator
-    set bar() {}
+  @AccessorDecorator
+  set bar() {}
 }
-        `,
+    `,
     `
 import { MethodDecoratorFactory } from 'decorators';
 export class Foo {
-    @MethodDecoratorFactory(false)
-    bar() {}
+  @MethodDecoratorFactory(false)
+  bar() {}
 }
-        `,
+    `,
     `
 import { MethodDecorator } from 'decorators';
 export class Foo {
-    @MethodDecorator
-    static bar() {}
+  @MethodDecorator
+  static bar() {}
 }
-        `,
+    `,
     `
 import { ConstructorParameterDecoratorFactory } from 'decorators';
 export class Service {
-    constructor(@ConstructorParameterDecoratorFactory(APP_CONFIG) config: AppConfig) {
-        this.title = config.title;
-    }
+  constructor(
+    @ConstructorParameterDecoratorFactory(APP_CONFIG) config: AppConfig,
+  ) {
+    this.title = config.title;
+  }
 }
-        `,
+    `,
     `
 import { ConstructorParameterDecorator } from 'decorators';
 export class Foo {
-   constructor(@ConstructorParameterDecorator bar) {
-       this.bar = bar;
-   }
+  constructor(@ConstructorParameterDecorator bar) {
+    this.bar = bar;
+  }
 }
-        `,
+    `,
     `
 import { ParameterDecoratorFactory } from 'decorators';
 export class Qux {
-   bar(@ParameterDecoratorFactory(true) baz: number) {
-       console.log(baz);
-   }
+  bar(@ParameterDecoratorFactory(true) baz: number) {
+    console.log(baz);
+  }
 }
-        `,
+    `,
     `
 import { ParameterDecorator } from 'decorators';
 export class Foo {
-   static greet(@ParameterDecorator name: string) {
-       return name;
-   }
+  static greet(@ParameterDecorator name: string) {
+    return name;
+  }
 }
-        `,
+    `,
     `
 import { Input, Output, EventEmitter } from 'decorators';
 export class SomeComponent {
-   @Input() data;
-   @Output()
-   click = new EventEmitter();
+  @Input() data;
+  @Output()
+  click = new EventEmitter();
 }
-        `,
+    `,
     `
 import { configurable } from 'decorators';
 export class A {
-   @configurable(true) static prop1;
+  @configurable(true) static prop1;
 
-   @configurable(false)
-   static prop2;
+  @configurable(false)
+  static prop2;
 }
-        `,
+    `,
     `
 import { foo, bar } from 'decorators';
 export class B {
-   @foo x;
+  @foo x;
 
-   @bar
-   y;
+  @bar
+  y;
 }
-        `,
+    `,
     `
 interface Base {}
 class Thing implements Base {}
-new Thing()
-		`,
+new Thing();
+    `,
     `
 interface Base {}
-const a: Base = {}
+const a: Base = {};
 console.log(a);
-        `,
+    `,
     `
-import { Foo } from 'foo'
+import { Foo } from 'foo';
 function bar<T>() {}
-bar<Foo>()
-        `,
+bar<Foo>();
+    `,
     `
-import { Foo } from 'foo'
-const bar = function <T>() {}
-bar<Foo>()
-        `,
+import { Foo } from 'foo';
+const bar = function<T>() {};
+bar<Foo>();
+    `,
     `
-import { Foo } from 'foo'
-const bar = <T>() => {}
-bar<Foo>()
-        `,
+import { Foo } from 'foo';
+const bar = <T>() => {};
+bar<Foo>();
+    `,
     `
-import { Foo } from 'foo'
-<Foo>(<T>() => {})()
-        `,
+import { Foo } from 'foo';
+<Foo>(<T>() => {})();
+    `,
     `
 import { Nullable } from 'nullable';
 const a: Nullable<string> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
 const a: Nullable<SomeOther> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 const a: Nullable | undefined = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 const a: Nullable & undefined = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
 const a: Nullable<SomeOther[]> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
 const a: Nullable<Array<SomeOther>> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 const a: Array<Nullable> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 const a: Nullable[] = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 const a: Array<Nullable[]> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 const a: Array<Array<Nullable>> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
 const a: Array<Nullable<SomeOther>> = 'hello';
 console.log(a);
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { Component } from 'react';
-class Foo implements Component<Nullable>{};
+class Foo implements Component<Nullable> {}
 
 new Foo();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { Component } from 'react';
-class Foo extends Component<Nullable, {}>{}
+class Foo extends Component<Nullable, {}> {}
 new Foo();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Component } from 'react';
-class Foo extends Component<Nullable<SomeOther>, {}>{}
+class Foo extends Component<Nullable<SomeOther>, {}> {}
 new Foo();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Component } from 'react';
-class Foo implements Component<Nullable<SomeOther>, {}>{}
+class Foo implements Component<Nullable<SomeOther>, {}> {}
 new Foo();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Component, Component2 } from 'react';
-class Foo implements Component<Nullable<SomeOther>, {}>, Component2{}
+class Foo implements Component<Nullable<SomeOther>, {}>, Component2 {}
 new Foo();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-    do = (a: Nullable<Another>) => { console.log(a); }
+  do = (a: Nullable<Another>) => {
+    console.log(a);
+  };
 }
 new A();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-    do(a: Nullable<Another>) { console.log(a); }
+  do(a: Nullable<Another>) {
+    console.log(a);
+  }
 }
 new A();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-    do(): Nullable<Another> { return null; }
+  do(): Nullable<Another> {
+    return null;
+  }
 }
 new A();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 interface A {
-    do(a: Nullable<Another>);
+  do(a: Nullable<Another>);
 }
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 interface A {
-    other: Nullable<Another>;
+  other: Nullable<Another>;
 }
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
-function foo(a: Nullable) { console.log(a); }
+function foo(a: Nullable) {
+  console.log(a);
+}
 foo();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
-function foo(): Nullable { return null; }
+function foo(): Nullable {
+  return null;
+}
 foo();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
 class A extends Nullable<SomeOther> {
-    other: Nullable<Another>;
+  other: Nullable<Another>;
 }
 new A();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
 class A extends Nullable<SomeOther> {
-    do(a: Nullable<Another>){ console.log(a); }
+  do(a: Nullable<Another>) {
+    console.log(a);
+  }
 }
 new A();
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
 interface A extends Nullable<SomeOther> {
-    other: Nullable<Another>;
+  other: Nullable<Another>;
 }
-		`,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
 interface A extends Nullable<SomeOther> {
-    do(a: Nullable<Another>);
+  do(a: Nullable<Another>);
 }
-        `,
+    `,
     `
 import { Foo } from './types';
 
 class Bar<T extends Foo> {}
 
-new Bar<number>()
-        `,
+new Bar<number>();
+    `,
     `
 import { Foo, Bar } from './types';
 
 class Baz<T extends Foo & Bar> {}
 
-new Baz<any>()
-        `,
+new Baz<any>();
+    `,
     `
 import { Foo } from './types';
 
 class Bar<T = Foo> {}
 
-new Bar<number>()
-        `,
+new Bar<number>();
+    `,
     `
 import { Foo } from './types';
 
 class Foo<T = any> {}
 
-new Foo()
-        `,
+new Foo();
+    `,
     `
 import { Foo } from './types';
 
 class Foo<T = {}> {}
 
-new Foo()
-        `,
+new Foo();
+    `,
     `
 import { Foo } from './types';
 
 class Foo<T extends {} = {}> {}
 
-new Foo()
-        `,
+new Foo();
+    `,
     `
-type Foo = "a" | "b" | "c"
-type Bar = number
+type Foo = 'a' | 'b' | 'c';
+type Bar = number;
 
 export const map: { [name in Foo]: Bar } = {
-    a: 1,
-    b: 2,
-    c: 3
-}
-        `,
+  a: 1,
+  b: 2,
+  c: 3,
+};
+    `,
     `
 import { Nullable } from 'nullable';
 class A<T> {
-    bar: T
+  bar: T;
 }
 new A<Nullable>();
-        `,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
-function foo<T extends Nullable>() {
-}
+function foo<T extends Nullable>() {}
 foo<SomeOther>();
-        `,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
 class A<T extends Nullable> {
-    bar: T;
+  bar: T;
 }
 new A<SomeOther>();
-        `,
+    `,
     `
 import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
 interface A<T extends Nullable> {
-    bar: T;
+  bar: T;
 }
 export const a: A<SomeOther> = {
-    foo: "bar"
+  foo: 'bar',
 };
-        `,
+    `,
     // https://github.com/bradzacher/eslint-plugin-typescript/issues/150
     `
 export class App {
-    constructor(private logger: Logger) {
-        console.log(this.logger);
-    }
+  constructor(private logger: Logger) {
+    console.log(this.logger);
+  }
 }
-        `,
+    `,
     `
 export class App {
-    constructor(bar: string);
-    constructor(private logger: Logger) {
-        console.log(this.logger);
-    }
+  constructor(bar: string);
+  constructor(private logger: Logger) {
+    console.log(this.logger);
+  }
 }
-        `,
+    `,
     `
 export class App {
-    constructor(baz: string, private logger: Logger) {
-        console.log(baz);
-        console.log(this.logger);
-    }
+  constructor(baz: string, private logger: Logger) {
+    console.log(baz);
+    console.log(this.logger);
+  }
 }
-        `,
+    `,
     `
 export class App {
-    constructor(baz: string, private logger: Logger, private bar: () => void) {
-        console.log(this.logger);
-        this.bar();
-    }
+  constructor(baz: string, private logger: Logger, private bar: () => void) {
+    console.log(this.logger);
+    this.bar();
+  }
 }
-        `,
+    `,
     `
 export class App {
-    constructor(private logger: Logger) {}
-    meth() {
-        console.log(this.logger);
-    }
+  constructor(private logger: Logger) {}
+  meth() {
+    console.log(this.logger);
+  }
 }
-        `,
+    `,
     // https://github.com/bradzacher/eslint-plugin-typescript/issues/126
     `
 import { Component, Vue } from 'vue-property-decorator';
@@ -451,96 +464,99 @@ import HelloWorld from './components/HelloWorld.vue';
 
 @Component({
   components: {
-    HelloWorld
-  }
+    HelloWorld,
+  },
 })
 export default class App extends Vue {}
-        `,
+    `,
     // https://github.com/bradzacher/eslint-plugin-typescript/issues/189
     `
-import firebase, {User} from 'firebase/app'
+import firebase, { User } from 'firebase/app';
 // initialize firebase project
-firebase.initializeApp({
-})
+firebase.initializeApp({});
 export function authenticated(cb: (user: User | null) => void): void {
-  firebase.auth().onAuthStateChanged(user => cb(user))
+  firebase.auth().onAuthStateChanged(user => cb(user));
 }
-        `,
+    `,
     // https://github.com/bradzacher/eslint-plugin-typescript/issues/33
     `
 import { Foo } from './types';
 export class Bar<T extends Foo> {}
-        `,
+    `,
     `
 import webpack from 'webpack';
 export default function webpackLoader(this: webpack.loader.LoaderContext) {}
-        `,
+    `,
     `
 import execa, { Options as ExecaOptions } from 'execa';
 export function foo(options: ExecaOptions): execa {
-    options()
+  options();
 }
-        `,
+    `,
     `
 import { Foo, Bar } from './types';
 export class Baz<F = Foo & Bar> {}
-        `,
+    `,
     `
 // warning 'B' is defined but never used
-export const a: Array<{b: B}> = []
-        `,
+export const a: Array<{ b: B }> = [];
+    `,
     `
 export enum FormFieldIds {
-	PHONE = 'phone',
-	EMAIL = 'email',
+  PHONE = 'phone',
+  EMAIL = 'email',
 }
-        `,
+    `,
     `
 enum FormFieldIds {
-	PHONE = 'phone',
-	EMAIL = 'email',
+  PHONE = 'phone',
+  EMAIL = 'email',
 }
 interface IFoo {
-	fieldName: FormFieldIds,
+  fieldName: FormFieldIds;
 }
-        `,
+    `,
     `
 enum FormFieldIds {
-    PHONE = 'phone',
-    EMAIL = 'email',
+  PHONE = 'phone',
+  EMAIL = 'email',
 }
 interface IFoo {
-    fieldName: FormFieldIds.EMAIL,
+  fieldName: FormFieldIds.EMAIL;
 }
     `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/25
     `
-import * as fastify from 'fastify'
-import { Server, IncomingMessage, ServerResponse } from 'http'
-const server: fastify.FastifyInstance<Server, IncomingMessage, ServerResponse> = fastify({})
-server.get('/ping')
+import * as fastify from 'fastify';
+import { Server, IncomingMessage, ServerResponse } from 'http';
+const server: fastify.FastifyInstance<
+  Server,
+  IncomingMessage,
+  ServerResponse
+> = fastify({});
+server.get('/ping');
     `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/61
-    `declare function foo();`,
+    'declare function foo();',
     // https://github.com/typescript-eslint/typescript-eslint/issues/61
     `
 declare namespace Foo {
-    function bar(line: string, index: number | null, tabSize: number): number;
-    var baz: string;
+  function bar(line: string, index: number | null, tabSize: number): number;
+  var baz: string;
 }
     `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/61
     `
 declare var Foo: {
-    new (value?: any): Object,
-    foo(): string
-}
+  new (value?: any): Object;
+  foo(): string;
+};
     `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/106
     `
 declare class Foo {
-    constructor(value?: any): Object;
-    foo(): string;
+  constructor(value?: any): Object;
+  foo(): string;
 }
     `,
     `
@@ -602,9 +618,9 @@ import { Dec, TypeA, Class } from 'test';
 export default class Foo {
   constructor(
     @Dec(Class)
-    ...prop: TypeA<Class>,
+    ...prop: TypeA<Class>
   ) {
-    prop()
+    prop();
   }
 }
     `,
@@ -615,7 +631,7 @@ export default class Foo {
       code: `
 import { ClassDecoratorFactory } from 'decorators';
 export class Foo {}
-            `,
+      `,
       errors: error([
         {
           message: "'ClassDecoratorFactory' is defined but never used.",
@@ -628,8 +644,8 @@ export class Foo {}
       code: `
 import { Foo, Bar } from 'foo';
 function baz<Foo>() {}
-baz<Bar>()
-            `,
+baz<Bar>();
+      `,
       errors: error([
         {
           message: "'Foo' is defined but never used.",
@@ -643,7 +659,7 @@ baz<Bar>()
 import { Nullable } from 'nullable';
 const a: string = 'hello';
 console.log(a);
-            `,
+      `,
       errors: error([
         {
           message: "'Nullable' is defined but never used.",
@@ -658,7 +674,7 @@ import { Nullable } from 'nullable';
 import { SomeOther } from 'other';
 const a: Nullable<string> = 'hello';
 console.log(a);
-            `,
+      `,
       errors: error([
         {
           message: "'SomeOther' is defined but never used.",
@@ -673,10 +689,12 @@ console.log(a);
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-    do = (a: Nullable) => { console.log(a); }
+  do = (a: Nullable) => {
+    console.log(a);
+  };
 }
 new A();
-            `,
+      `,
       errors: error([
         {
           message: "'Another' is defined but never used.",
@@ -690,10 +708,12 @@ new A();
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-    do(a: Nullable) { console.log(a); }
+  do(a: Nullable) {
+    console.log(a);
+  }
 }
 new A();
-            `,
+      `,
       errors: error([
         {
           message: "'Another' is defined but never used.",
@@ -707,10 +727,12 @@ new A();
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 class A {
-    do(): Nullable { return null; }
+  do(): Nullable {
+    return null;
+  }
 }
 new A();
-            `,
+      `,
       errors: error([
         {
           message: "'Another' is defined but never used.",
@@ -724,9 +746,9 @@ new A();
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 interface A {
-    do(a: Nullable);
+  do(a: Nullable);
 }
-            `,
+      `,
       errors: error([
         {
           message: "'Another' is defined but never used.",
@@ -740,9 +762,9 @@ interface A {
 import { Nullable } from 'nullable';
 import { Another } from 'some';
 interface A {
-    other: Nullable;
+  other: Nullable;
 }
-            `,
+      `,
       errors: error([
         {
           message: "'Another' is defined but never used.",
@@ -754,9 +776,11 @@ interface A {
     {
       code: `
 import { Nullable } from 'nullable';
-function foo(a: string) { console.log(a); }
+function foo(a: string) {
+  console.log(a);
+}
 foo();
-            `,
+      `,
       errors: error([
         {
           message: "'Nullable' is defined but never used.",
@@ -768,9 +792,11 @@ foo();
     {
       code: `
 import { Nullable } from 'nullable';
-function foo(): string | null { return null; }
+function foo(): string | null {
+  return null;
+}
 foo();
-            `,
+      `,
       errors: error([
         {
           message: "'Nullable' is defined but never used.",
@@ -785,10 +811,10 @@ import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
 class A extends Nullable {
-    other: Nullable<Another>;
+  other: Nullable<Another>;
 }
 new A();
-            `,
+      `,
       errors: error([
         {
           message: "'SomeOther' is defined but never used.",
@@ -803,10 +829,10 @@ import { Nullable } from 'nullable';
 import { SomeOther } from 'some';
 import { Another } from 'some';
 abstract class A extends Nullable {
-    other: Nullable<Another>;
+  other: Nullable<Another>;
 }
 new A();
-            `,
+      `,
       errors: error([
         {
           message: "'SomeOther' is defined but never used.",
@@ -818,10 +844,10 @@ new A();
     {
       code: `
 enum FormFieldIds {
-    PHONE = 'phone',
-    EMAIL = 'email',
+  PHONE = 'phone',
+  EMAIL = 'email',
 }
-            `,
+      `,
       errors: error([
         {
           message: "'FormFieldIds' is defined but never used.",
@@ -835,7 +861,7 @@ enum FormFieldIds {
 import test from 'test';
 import baz from 'baz';
 export interface Bar extends baz.test {}
-    `,
+      `,
       errors: error([
         {
           message: "'test' is defined but never used.",
@@ -849,7 +875,7 @@ export interface Bar extends baz.test {}
 import test from 'test';
 import baz from 'baz';
 export interface Bar extends baz().test {}
-    `,
+      `,
       errors: error([
         {
           message: "'test' is defined but never used.",
@@ -863,7 +889,7 @@ export interface Bar extends baz().test {}
 import test from 'test';
 import baz from 'baz';
 export class Bar implements baz.test {}
-    `,
+      `,
       errors: error([
         {
           message: "'test' is defined but never used.",
@@ -877,7 +903,7 @@ export class Bar implements baz.test {}
 import test from 'test';
 import baz from 'baz';
 export class Bar implements baz().test {}
-    `,
+      `,
       errors: error([
         {
           message: "'test' is defined but never used.",
diff --git a/packages/eslint-plugin/tests/rules/no-use-before-define.test.ts b/packages/eslint-plugin/tests/rules/no-use-before-define.test.ts
index 70d91022816..dbbfcd61f5a 100644
--- a/packages/eslint-plugin/tests/rules/no-use-before-define.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-use-before-define.test.ts
@@ -10,21 +10,44 @@ const parserOptions = { ecmaVersion: 6 as const };
 
 ruleTester.run('no-use-before-define', rule, {
   valid: [
-    'type foo = 1; const x: foo = 1;',
-    'type foo = 1; type bar = foo;',
+    `
+type foo = 1;
+const x: foo = 1;
+    `,
+    `
+type foo = 1;
+type bar = foo;
+    `,
     `
 interface Foo {}
 const x: Foo = {};
     `,
-    'var a=10; alert(a);',
-    'function b(a) { alert(a); }',
+    `
+var a = 10;
+alert(a);
+    `,
+    `
+function b(a) {
+  alert(a);
+}
+    `,
     'Object.hasOwnProperty.call(a);',
-    'function a() { alert(arguments);}',
-    'declare function a()',
-    'declare class a { foo() }',
-    `const updatedAt = data?.updatedAt;`,
     `
-function f() { return function t() {}; }
+function a() {
+  alert(arguments);
+}
+    `,
+    'declare function a();',
+    `
+declare class a {
+  foo();
+}
+    `,
+    'const updatedAt = data?.updatedAt;',
+    `
+function f() {
+  return function t() {};
+}
 f()?.();
     `,
     `
@@ -34,94 +57,106 @@ alert(a?.b);
     {
       code: `
 a();
-function a() { alert(arguments); }
-            `,
+function a() {
+  alert(arguments);
+}
+      `,
       options: ['nofunc'],
     },
     {
-      code: '(() => { var a = 42; alert(a); })();',
+      code: `
+(() => {
+  var a = 42;
+  alert(a);
+})();
+      `,
       parserOptions,
     },
     `
 a();
 try {
-    throw new Error()
+  throw new Error();
 } catch (a) {}
-        `,
+    `,
     {
       code: `
 class A {}
 new A();
-            `,
+      `,
       parserOptions,
     },
-    'var a = 0, b = a;',
-    { code: 'var {a = 0, b = a} = {};', parserOptions },
+    `
+var a = 0,
+  b = a;
+    `,
+    { code: 'var { a = 0, b = a } = {};', parserOptions },
     { code: 'var [a = 0, b = a] = {};', parserOptions },
     `
 function foo() {
-    foo();
+  foo();
 }
-        `,
+    `,
     `
 var foo = function() {
-    foo();
+  foo();
 };
-        `,
+    `,
     `
 var a;
-for (a in a) {}
-        `,
+for (a in a) {
+}
+    `,
     {
       code: `
 var a;
-for (a of a) {}
-            `,
+for (a of a) {
+}
+      `,
       parserOptions,
     },
 
     // Block-level bindings
     {
       code: `
-"use strict";
+'use strict';
 a();
 {
-    function a() {}
+  function a() {}
 }
-            `,
+      `,
       parserOptions,
     },
     {
       code: `
-"use strict";
+'use strict';
 {
-    a();
-    function a() {}
+  a();
+  function a() {}
 }
-            `,
+      `,
       options: ['nofunc'],
       parserOptions,
     },
     {
       code: `
 switch (foo) {
-    case 1: {
-        a();
-    }
-    default: {
-        let a;
-    }
+  case 1: {
+    a();
+  }
+  default: {
+    let a;
+  }
 }
-            `,
+      `,
       parserOptions,
     },
     {
       code: `
 a();
 {
-    let a = function () {};
+  let a = function() {};
 }
-            `,
+      `,
       parserOptions,
     },
 
@@ -130,29 +165,29 @@ a();
       code: `
 a();
 function a() {
-    alert(arguments);
+  alert(arguments);
 }
-            `,
+      `,
       options: [{ functions: false }],
     },
     {
       code: `
-"use strict";
+'use strict';
 {
-    a();
-    function a() {}
+  a();
+  function a() {}
 }
-            `,
+      `,
       options: [{ functions: false }],
       parserOptions,
     },
     {
       code: `
 function foo() {
-    new A();
+  new A();
 }
-class A {};
-            `,
+class A {}
+      `,
       options: [{ classes: false }],
       parserOptions,
     },
@@ -161,17 +196,17 @@ class A {};
     {
       code: `
 function foo() {
-    bar;
+  bar;
 }
 var bar;
-            `,
+      `,
       options: [{ variables: false }],
     },
     {
       code: `
 var foo = () => bar;
 var bar;
-            `,
+      `,
       options: [{ variables: false }],
       parserOptions,
     },
@@ -180,8 +215,8 @@ var bar;
     {
       code: `
 var x: Foo = 2;
-type Foo = string | number
-            `,
+type Foo = string | number;
+      `,
       options: [{ typedefs: false }],
     },
 
@@ -191,7 +226,7 @@ type Foo = string | number
 var alias = Test;
 
 class Test {}
-            `,
+      `,
       parserOptions,
       options: [{ classes: false }],
     },
@@ -200,7 +235,7 @@ class Test {}
 var alias = Test;
 
 export class Test {}
-            `,
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       options: [{ classes: false }],
     },
@@ -208,9 +243,9 @@ export class Test {}
     {
       code: `
 interface ITest {
-  first : boolean;
-  second : string;
-  third : boolean;
+  first: boolean;
+  second: string;
+  third: boolean;
 }
 
 let first = () => console.log('first');
@@ -220,23 +255,23 @@ export let second = () => console.log('second');
 export namespace Third {
   export let third = () => console.log('third');
 }
-            `,
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
     },
     // https://github.com/eslint/typescript-eslint-parser/issues/550
     `
 function test(file: Blob) {
   const slice: typeof file.slice =
-    file.slice || (file as any).webkitSlice || (file as any).mozSlice
-  return slice
+    file.slice || (file as any).webkitSlice || (file as any).mozSlice;
+  return slice;
 }
     `,
     // https://github.com/eslint/typescript-eslint-parser/issues/435
     `
 interface Foo {
-    bar: string
+  bar: string;
 }
-const bar = 'blah'
+const bar = 'blah';
     `,
     {
       code: `
@@ -279,8 +314,8 @@ enum Foo {
     {
       code: `
 a++;
-var a=19;
-            `,
+var a = 19;
+      `,
       parserOptions: { sourceType: 'module' },
       errors: [
         {
@@ -293,8 +328,8 @@ var a=19;
     {
       code: `
 a++;
-var a=19;
-            `,
+var a = 19;
+      `,
       parserOptions,
       errors: [
         {
@@ -307,8 +342,8 @@ var a=19;
     {
       code: `
 a++;
-var a=19;
-            `,
+var a = 19;
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -320,8 +355,8 @@ var a=19;
     {
       code: `
 a();
-var a=function() {};
-            `,
+var a = function() {};
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -333,8 +368,8 @@ var a=function() {};
     {
       code: `
 alert(a[1]);
-var a=[1,3];
-            `,
+var a = [1, 3];
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -347,11 +382,11 @@ var a=[1,3];
       code: `
 a();
 function a() {
-    alert(b);
-    var b=10;
-    a();
+  alert(b);
+  var b = 10;
+  a();
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -368,9 +403,8 @@ function a() {
     {
       code: `
 a();
-var a=function() {};
-
-            `,
+var a = function() {};
+      `,
       options: ['nofunc'],
       errors: [
         {
@@ -382,13 +416,11 @@ var a=function() {};
     },
     {
       code: `
-(
-    () => {
-        alert(a);
-        var a = 42;
-    }
-)();
-            `,
+(() => {
+  alert(a);
+  var a = 42;
+})();
+      `,
       parserOptions,
       errors: [
         {
@@ -400,11 +432,9 @@ var a=function() {};
     },
     {
       code: `
-(
-    () => a()
-)();
-function a() { }
-            `,
+(() => a())();
+function a() {}
+      `,
       parserOptions,
       errors: [
         {
@@ -416,12 +446,12 @@ function a() { }
     },
     {
       code: `
-"use strict";
+'use strict';
 a();
 {
-    function a() {}
+  function a() {}
 }
-            `,
+      `,
       parser: require.resolve('espree'),
       errors: [
         {
@@ -435,11 +465,11 @@ a();
       code: `
 a();
 try {
-    throw new Error()
+  throw new Error();
 } catch (foo) {
-    var a;
+  var a;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -452,7 +482,7 @@ try {
       code: `
 var f = () => a;
 var a;
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -465,8 +495,8 @@ var a;
     {
       code: `
 new A();
-class A {};
-            `,
+class A {}
+      `,
       parserOptions,
       errors: [
         {
@@ -479,10 +509,10 @@ class A {};
     {
       code: `
 function foo() {
-    new A();
+  new A();
 }
-class A {};
-            `,
+class A {}
+      `,
       parserOptions,
       errors: [
         {
@@ -496,7 +526,7 @@ class A {};
       code: `
 new A();
 var A = class {};
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -509,10 +539,10 @@ var A = class {};
     {
       code: `
 function foo() {
-    new A();
+  new A();
 }
 var A = class {};
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -528,9 +558,9 @@ var A = class {};
       code: `
 a++;
 {
-    var a;
+  var a;
 }
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -542,12 +572,12 @@ a++;
     },
     {
       code: `
-"use strict";
+'use strict';
 {
-    a();
-    function a() {}
+  a();
+  function a() {}
 }
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -560,10 +590,10 @@ a++;
     {
       code: `
 {
-    a;
-    let a = 1
+  a;
+  let a = 1;
 }
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -576,12 +606,12 @@ a++;
     {
       code: `
 switch (foo) {
-    case 1:
-        a();
-    default:
-        let a;
+  case 1:
+    a();
+  default:
+    let a;
 }
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -594,12 +624,12 @@ switch (foo) {
     {
       code: `
 if (true) {
-    function foo() {
-        a;
-    }
-    let a;
+  function foo() {
+    a;
+  }
+  let a;
 }
-            `,
+      `,
       parserOptions,
       errors: [
         {
@@ -614,8 +644,8 @@ if (true) {
     {
       code: `
 a();
-var a=function() {};
-            `,
+var a = function() {};
+      `,
       options: [{ functions: false, classes: false }],
       errors: [
         {
@@ -629,7 +659,7 @@ var a=function() {};
       code: `
 new A();
 var A = class {};
-            `,
+      `,
       options: [{ classes: false }],
       parserOptions,
       errors: [
@@ -643,10 +673,10 @@ var A = class {};
     {
       code: `
 function foo() {
-    new A();
+  new A();
 }
 var A = class {};
-            `,
+      `,
       options: [{ classes: false }],
       parserOptions,
       errors: [
@@ -703,7 +733,7 @@ var A = class {};
       ],
     },
     {
-      code: 'var {a = a} = [];',
+      code: 'var { a = a } = [];',
       parserOptions,
       errors: [
         {
@@ -725,7 +755,7 @@ var A = class {};
       ],
     },
     {
-      code: 'var {b = a, a} = {};',
+      code: 'var { b = a, a } = {};',
       parserOptions,
       errors: [
         {
@@ -747,7 +777,7 @@ var A = class {};
       ],
     },
     {
-      code: 'var {a = 0} = a;',
+      code: 'var { a = 0 } = a;',
       parserOptions,
       errors: [
         {
@@ -769,7 +799,10 @@ var A = class {};
       ],
     },
     {
-      code: 'for (var a in a) {}',
+      code: `
+for (var a in a) {
+}
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -779,7 +812,10 @@ var A = class {};
       ],
     },
     {
-      code: 'for (var a of a) {}',
+      code: `
+for (var a of a) {
+}
+      `,
       parserOptions,
       errors: [
         {
@@ -794,8 +830,8 @@ var A = class {};
     {
       code: `
 function foo() {
-    bar;
-    var bar = 1;
+  bar;
+  var bar = 1;
 }
 var bar;
       `,
@@ -864,7 +900,7 @@ enum Foo {
       code: `
 f();
 function f() {}
-    `,
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -876,7 +912,7 @@ function f() {}
       code: `
 alert(a);
 var a = 10;
-    `,
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -890,7 +926,7 @@ f()?.();
 function f() {
   return function t() {};
 }
-    `,
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
@@ -902,7 +938,7 @@ function f() {
       code: `
 alert(a?.b);
 var a = { b: 5 };
-    `,
+      `,
       errors: [
         {
           messageId: 'noUseBeforeDefine',
diff --git a/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts b/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
index 49b362f4d9f..412aab3a1f1 100644
--- a/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-useless-constructor.test.ts
@@ -19,83 +19,283 @@ const error: any = {
 
 ruleTester.run('no-useless-constructor', rule, {
   valid: [
-    'class A { }',
-    'class A { constructor(){ doSomething(); } }',
-    'class A extends B { constructor(){} }',
-    "class A extends B { constructor(){ super('foo'); } }",
-    'class A extends B { constructor(foo, bar){ super(foo, bar, 1); } }',
-    'class A extends B { constructor(){ super(); doSomething(); } }',
-    'class A extends B { constructor(...args){ super(...args); doSomething(); } }',
-    'class A { dummyMethod(){ doSomething(); } }',
-    'class A extends B.C { constructor() { super(foo); } }',
-    'class A extends B.C { constructor([a, b, c]) { super(...arguments); } }',
-    'class A extends B.C { constructor(a = f()) { super(...arguments); } }',
-    'class A extends B { constructor(a, b, c) { super(a, b); } }',
-    'class A extends B { constructor(foo, bar){ super(foo); } }',
-    'class A extends B { constructor(test) { super(); } }',
-    'class A extends B { constructor() { foo; } }',
-    'class A extends B { constructor(foo, bar) { super(bar); } }',
+    'class A {}',
+    `
+class A {
+  constructor() {
+    doSomething();
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor() {}
+}
+    `,
+    `
+class A extends B {
+  constructor() {
+    super('foo');
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor(foo, bar) {
+    super(foo, bar, 1);
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor() {
+    super();
+    doSomething();
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor(...args) {
+    super(...args);
+    doSomething();
+  }
+}
+    `,
+    `
+class A {
+  dummyMethod() {
+    doSomething();
+  }
+}
+    `,
+    `
+class A extends B.C {
+  constructor() {
+    super(foo);
+  }
+}
+    `,
+    `
+class A extends B.C {
+  constructor([a, b, c]) {
+    super(...arguments);
+  }
+}
+    `,
+    `
+class A extends B.C {
+  constructor(a = f()) {
+    super(...arguments);
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor(a, b, c) {
+    super(a, b);
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor(foo, bar) {
+    super(foo);
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor(test) {
+    super();
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor() {
+    foo;
+  }
+}
+    `,
+    `
+class A extends B {
+  constructor(foo, bar) {
+    super(bar);
+  }
+}
+    `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/15
-    'declare class A { constructor(); }',
-    'class A { constructor(); }',
-    'abstract class A { constructor(); }',
-    'abstract class A { abstract constructor(); }',
+    `
+declare class A {
+  constructor();
+}
+    `,
+    `
+class A {
+  constructor();
+}
+    `,
+    `
+abstract class A {
+  constructor();
+}
+    `,
+    `
+abstract class A {
+  abstract constructor();
+}
+    `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/48
-    'class A { constructor(private name: string) {} }',
-    'class A { constructor(public name: string) {} }',
-    'class A { constructor(protected name: string) {} }',
+    `
+class A {
+  constructor(private name: string) {}
+}
+    `,
+    `
+class A {
+  constructor(public name: string) {}
+}
+    `,
+    `
+class A {
+  constructor(protected name: string) {}
+}
+    `,
     // https://github.com/typescript-eslint/typescript-eslint/pull/167#discussion_r252638401
-    'class A { private constructor() {} }',
-    'class A { protected constructor() {} }',
-    'class A extends B { public constructor() {} }',
-    'class A extends B { protected constructor(foo, bar) { super(bar); } }',
-    'class A extends B { private constructor(foo, bar) { super(bar); } }',
-    'class A extends B { public constructor(foo){ super(foo); } }',
-    'class A extends B { public constructor(foo){} }',
+    `
+class A {
+  private constructor() {}
+}
+    `,
+    `
+class A {
+  protected constructor() {}
+}
+    `,
+    `
+class A extends B {
+  public constructor() {}
+}
+    `,
+    `
+class A extends B {
+  protected constructor(foo, bar) {
+    super(bar);
+  }
+}
+    `,
+    `
+class A extends B {
+  private constructor(foo, bar) {
+    super(bar);
+  }
+}
+    `,
+    `
+class A extends B {
+  public constructor(foo) {
+    super(foo);
+  }
+}
+    `,
+    `
+class A extends B {
+  public constructor(foo) {}
+}
+    `,
     // type definition / overload
-    'class A { constructor(foo); }',
+    `
+class A {
+  constructor(foo);
+}
+    `,
   ],
   invalid: [
     {
-      code: 'class A { constructor(){} }',
+      code: `
+class A {
+  constructor() {}
+}
+      `,
       errors: [error],
     },
     {
-      code: "class A { 'constructor'(){} }",
+      code: `
+class A extends B {
+  constructor() {
+    super();
+  }
+}
+      `,
       errors: [error],
     },
     {
-      code: 'class A extends B { constructor() { super(); } }',
+      code: `
+class A extends B {
+  constructor(foo) {
+    super(foo);
+  }
+}
+      `,
       errors: [error],
     },
     {
-      code: 'class A extends B { constructor(foo){ super(foo); } }',
+      code: `
+class A extends B {
+  constructor(foo, bar) {
+    super(foo, bar);
+  }
+}
+      `,
       errors: [error],
     },
     {
-      code: 'class A extends B { constructor(foo, bar){ super(foo, bar); } }',
+      code: `
+class A extends B {
+  constructor(...args) {
+    super(...args);
+  }
+}
+      `,
       errors: [error],
     },
     {
-      code: 'class A extends B { constructor(...args){ super(...args); } }',
+      code: `
+class A extends B.C {
+  constructor() {
+    super(...arguments);
+  }
+}
+      `,
       errors: [error],
     },
     {
-      code: 'class A extends B.C { constructor() { super(...arguments); } }',
+      code: `
+class A extends B {
+  constructor(a, b, ...c) {
+    super(...arguments);
+  }
+}
+      `,
       errors: [error],
     },
     {
-      code:
-        'class A extends B { constructor(a, b, ...c) { super(...arguments); } }',
+      code: `
+class A extends B {
+  constructor(a, b, ...c) {
+    super(a, b, ...c);
+  }
+}
+      `,
       errors: [error],
     },
     {
-      code:
-        'class A extends B { constructor(a, b, ...c) { super(a, b, ...c); } }',
-      errors: [error],
-    },
-    {
-      code: 'class A { public constructor() {} }',
+      code: `
+class A {
+  public constructor() {}
+}
+      `,
       errors: [error],
     },
   ],
diff --git a/packages/eslint-plugin/tests/rules/no-var-requires.test.ts b/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
index 4433a634c7b..25d53d9ab94 100644
--- a/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-var-requires.test.ts
@@ -6,10 +6,14 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run('no-var-requires', rule, {
-  valid: ["import foo = require('foo')", "require('foo')", "require?.('foo')"],
+  valid: [
+    "import foo = require('foo');",
+    "require('foo');",
+    "require?.('foo');",
+  ],
   invalid: [
     {
-      code: "var foo = require('foo')",
+      code: "var foo = require('foo');",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -19,7 +23,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "const foo = require('foo')",
+      code: "const foo = require('foo');",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -29,7 +33,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "let foo = require('foo')",
+      code: "let foo = require('foo');",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -39,7 +43,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "let foo = trick(require('foo'))",
+      code: "let foo = trick(require('foo'));",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -49,7 +53,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "var foo = require?.('foo')",
+      code: "var foo = require?.('foo');",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -59,7 +63,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "const foo = require?.('foo')",
+      code: "const foo = require?.('foo');",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -69,7 +73,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "let foo = require?.('foo')",
+      code: "let foo = require?.('foo');",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -79,7 +83,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "let foo = trick(require?.('foo'))",
+      code: "let foo = trick(require?.('foo'));",
       errors: [
         {
           messageId: 'noVarReqs',
@@ -89,7 +93,7 @@ ruleTester.run('no-var-requires', rule, {
       ],
     },
     {
-      code: "let foo = trick?.(require('foo'))",
+      code: "let foo = trick?.(require('foo'));",
       errors: [
         {
           messageId: 'noVarReqs',
diff --git a/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts b/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
index c18ac5d7f14..d5c15474f69 100644
--- a/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-as-const.test.ts
@@ -7,12 +7,12 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('prefer-as-const', rule, {
   valid: [
-    "let foo = 'baz' as const",
-    'let foo = 1 as const',
-    "let foo = { bar: 'baz' as const }",
-    'let foo = { bar: 1 as const }',
-    "let foo = { bar: 'baz' }",
-    'let foo = { bar: 2 }',
+    "let foo = 'baz' as const;",
+    'let foo = 1 as const;',
+    "let foo = { bar: 'baz' as const };",
+    'let foo = { bar: 1 as const };',
+    "let foo = { bar: 'baz' };",
+    'let foo = { bar: 2 };',
     "let foo = <bar>'bar';",
     "let foo = <string>'bar';",
     "let foo = 'bar' as string;",
@@ -23,16 +23,24 @@ ruleTester.run('prefer-as-const', rule, {
     'let foo: number = 1;',
     "let foo: 'bar' = baz;",
     "let foo = 'bar';",
-    'class foo { bar: "baz" = "baz" }',
-    'class foo { bar = "baz" }',
-    "let foo: 'bar'",
-    'let foo = { bar }',
-    "let foo: 'baz' = 'baz' as const",
+    `
+      class foo {
+        bar: 'baz' = 'baz';
+      }
+    `,
+    `
+      class foo {
+        bar = 'baz';
+      }
+    `,
+    "let foo: 'bar';",
+    'let foo = { bar };',
+    "let foo: 'baz' = 'baz' as const;",
   ],
   invalid: [
     {
-      code: "let foo = { bar: 'baz' as 'baz' }",
-      output: "let foo = { bar: 'baz' as const }",
+      code: "let foo = { bar: 'baz' as 'baz' };",
+      output: "let foo = { bar: 'baz' as const };",
       errors: [
         {
           messageId: 'preferConstAssertion',
@@ -42,8 +50,8 @@ ruleTester.run('prefer-as-const', rule, {
       ],
     },
     {
-      code: 'let foo = { bar: 1 as 1 }',
-      output: 'let foo = { bar: 1 as const }',
+      code: 'let foo = { bar: 1 as 1 };',
+      output: 'let foo = { bar: 1 as const };',
       errors: [
         {
           messageId: 'preferConstAssertion',
diff --git a/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts b/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
index 0e22722afb4..d2d7319b3b1 100644
--- a/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-for-of.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/prefer-for-of';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
@@ -11,42 +11,42 @@ ruleTester.run('prefer-for-of', rule, {
 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) {
+  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 h = 0, len = arr.length; h < len; h++) {}
+    `,
     `
-for(var i=0, len=arr.length; i < len; i++) arr[i];
-`,
+for (var i = 0, len = arr.length; i < len; i++) arr[i];
+    `,
     `
 var m = 0;
 for (;;) {
@@ -54,107 +54,106 @@ for (;;) {
   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 (; x < arr.length; x++) {}
+    `,
     `
-for(let x = 0;; x++) {}
-`,
+for (let x = 0; ; x++) {}
+    `,
     `
-for(let x = 0; x < arr.length;) {}
-`,
+for (let x = 0; x < arr.length; ) {}
+    `,
     `
-for(let x = 0; NOTX < arr.length; x++) {}
-`,
+for (let x = 0; NOTX < arr.length; x++) {}
+    `,
     `
-for(let x = 0; x < arr.length; NOTX++) {}
-`,
+for (let x = 0; x < arr.length; NOTX++) {}
+    `,
     `
-for(let NOTX = 0; x < arr.length; x++) {}
-`,
+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 = 0; x <= arr.length; x++) {}
-`,
+for (let x = 0; x <= arr.length; x++) {}
+    `,
     `
-for(let x = 1; 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++) {}
+    `,
     `
-for(let x = 0; x < arr.length; x+=11) {}
-`,
+for (let x = 0; x < arr.length; x += 11) {}
+    `,
     `
-for(let x = arr.length; x > 1; x-=1) {}
-`,
+for (let x = arr.length; x > 1; x -= 1) {}
+    `,
     `
-for(let x = 0; x < arr.length; x*=2) {}
-`,
+for (let x = 0; x < arr.length; x *= 2) {}
+    `,
     `
-for(let x = 0; x < arr.length; x=x+11) {}
-`,
+for (let x = 0; x < arr.length; x = x + 11) {}
+    `,
     `
-for(let x = 0; x < arr.length; x++) {
+for (let x = 0; x < arr.length; x++) {
   x++;
 }
-`,
+    `,
     `
-for(let x = 0; true; 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];
 }
-`,
-    `
+    `,
+    noFormat`
 for (let i = 0; i < arr.length; i++) {
   ({ foo: arr[i] }) = { foo: 0 };
 }
-`,
+    `,
     `
 for (let i = 0; i < arr1?.length; i++) {
   const x = arr1[i] === arr2[i];
@@ -188,7 +187,7 @@ for (var d = 0; d < arr.length; d++) doMath?.(d);
 for (var a = 0; a < obj.arr.length; a++) {
   console.log(obj.arr[a]);
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -198,7 +197,7 @@ for (var a = 0; a < obj.arr.length; a++) {
     {
       code: `
 for (var b = 0; b < arr.length; b++) console.log(arr[b]);
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -220,7 +219,7 @@ for (let a = 0; a < arr.length; a++) {
     {
       code: `
 for (var b = 0; b < arr.length; b++) console?.log(arr[b]);
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -232,7 +231,7 @@ for (var b = 0; b < arr.length; b++) console?.log(arr[b]);
 for (let a = 0; a < arr.length; a++) {
   console?.log(arr[a]);
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -244,7 +243,7 @@ for (let a = 0; a < arr.length; a++) {
 for (let a = 0; a < arr.length; ++a) {
   arr[a].whatever();
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -253,8 +252,8 @@ for (let a = 0; a < arr.length; ++a) {
     },
     {
       code: `
-for(let x = 0; x < arr.length; x++) {}
-        `,
+for (let x = 0; x < arr.length; x++) {}
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -263,8 +262,8 @@ for(let x = 0; x < arr.length; x++) {}
     },
     {
       code: `
-for(let x = 0; x < arr.length; x+=1) {}
-        `,
+for (let x = 0; x < arr.length; x += 1) {}
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -273,8 +272,8 @@ for(let x = 0; x < arr.length; x+=1) {}
     },
     {
       code: `
-for(let x = 0; x < arr.length; x=x+1) {}
-        `,
+for (let x = 0; x < arr.length; x = x + 1) {}
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -283,8 +282,8 @@ for(let x = 0; x < arr.length; x=x+1) {}
     },
     {
       code: `
-for(let x = 0; x < arr.length; x=1+x) {}
-        `,
+for (let x = 0; x < arr.length; x = 1 + x) {}
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -294,10 +293,9 @@ for(let x = 0; x < arr.length; x=1+x) {}
     {
       code: `
 for (let shadow = 0; shadow < arr.length; shadow++) {
-  for (let shadow = 0; shadow < arr.length; shadow++) {
-  }
+  for (let shadow = 0; shadow < arr.length; shadow++) {}
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -312,7 +310,7 @@ for (let shadow = 0; shadow < arr.length; shadow++) {
 for (let i = 0; i < arr.length; i++) {
   obj[arr[i]] = 1;
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -324,7 +322,7 @@ for (let i = 0; i < arr.length; i++) {
 for (let i = 0; i < arr.length; i++) {
   delete obj[arr[i]];
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -336,7 +334,7 @@ for (let i = 0; i < arr.length; i++) {
 for (let i = 0; i < arr.length; i++) {
   [obj[arr[i]]] = [1];
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -348,7 +346,7 @@ for (let i = 0; i < arr.length; i++) {
 for (let i = 0; i < arr.length; i++) {
   [...obj[arr[i]]] = [1];
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
@@ -358,9 +356,9 @@ for (let i = 0; i < arr.length; i++) {
     {
       code: `
 for (let i = 0; i < arr.length; i++) {
-  ({ foo: obj[arr[i]] }) = { foo: 1 };
+  ({ foo: obj[arr[i]] } = { foo: 1 });
 }
-        `,
+      `,
       errors: [
         {
           messageId: 'preferForOf',
diff --git a/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts b/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
index b4c6b4a3de8..257bd9e20d8 100644
--- a/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-function-type.test.ts
@@ -14,30 +14,35 @@ ruleTester.run('prefer-function-type', rule, {
 interface Foo {
   (): void;
   bar: number;
-}`,
+}
+    `,
     `
 type Foo = {
   (): void;
   bar: number;
-}`,
+};
+    `,
     `
-function foo(bar: { (): string, baz: number }): string {
+function foo(bar: { (): string; baz: number }): string {
   return bar();
-}`,
+}
+    `,
     `
 interface Foo {
   bar: string;
 }
 interface Bar extends Foo {
   (): void;
-}`,
+}
+    `,
     `
 interface Foo {
   bar: string;
 }
 interface Bar extends Function, Foo {
   (): void;
-}`,
+}
+    `,
   ],
 
   invalid: [
@@ -45,7 +50,8 @@ interface Bar extends Function, Foo {
       code: `
 interface Foo {
   (): string;
-}`,
+}
+      `,
       errors: [
         {
           messageId: 'functionTypeOverCallableType',
@@ -53,13 +59,15 @@ interface Foo {
         },
       ],
       output: `
-type Foo = () => string;`,
+type Foo = () => string;
+      `,
     },
     {
       code: `
 type Foo = {
   (): string;
-}`,
+};
+      `,
       errors: [
         {
           messageId: 'functionTypeOverCallableType',
@@ -67,13 +75,15 @@ type Foo = {
         },
       ],
       output: `
-type Foo = () => string`,
+type Foo = () => string;
+      `,
     },
     {
       code: `
 function foo(bar: { (s: string): number }): number {
-  return bar("hello");
-}`,
+  return bar('hello');
+}
+      `,
       errors: [
         {
           messageId: 'functionTypeOverCallableType',
@@ -82,14 +92,16 @@ function foo(bar: { (s: string): number }): number {
       ],
       output: `
 function foo(bar: (s: string) => number): number {
-  return bar("hello");
-}`,
+  return bar('hello');
+}
+      `,
     },
     {
       code: `
 function foo(bar: { (s: string): number } | undefined): number {
-  return bar("hello");
-}`,
+  return bar('hello');
+}
+      `,
       errors: [
         {
           messageId: 'functionTypeOverCallableType',
@@ -98,14 +110,16 @@ function foo(bar: { (s: string): number } | undefined): number {
       ],
       output: `
 function foo(bar: ((s: string) => number) | undefined): number {
-  return bar("hello");
-}`,
+  return bar('hello');
+}
+      `,
     },
     {
       code: `
 interface Foo extends Function {
   (): void;
-}`,
+}
+      `,
       errors: [
         {
           messageId: 'functionTypeOverCallableType',
@@ -113,13 +127,15 @@ interface Foo extends Function {
         },
       ],
       output: `
-type Foo = () => void;`,
+type Foo = () => void;
+      `,
     },
     {
       code: `
 interface Foo<T> {
   (bar: T): string;
-}`,
+}
+      `,
       errors: [
         {
           messageId: 'functionTypeOverCallableType',
@@ -127,7 +143,8 @@ interface Foo<T> {
         },
       ],
       output: `
-type Foo<T> = (bar: T) => string;`,
+type Foo<T> = (bar: T) => string;
+      `,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts b/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
index 47ebc5fd5e9..b512cea6757 100644
--- a/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-namespace-keyword.test.ts
@@ -7,16 +7,16 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('prefer-namespace-keyword', rule, {
   valid: [
-    "declare module 'foo'",
-    "declare module 'foo' { }",
-    'namespace foo { }',
-    'declare namespace foo { }',
-    'declare global { }',
+    "declare module 'foo';",
+    "declare module 'foo' {}",
+    'namespace foo {}',
+    'declare namespace foo {}',
+    'declare global {}',
   ],
   invalid: [
     {
-      code: 'module foo { }',
-      output: 'namespace foo { }',
+      code: 'module foo {}',
+      output: 'namespace foo {}',
       errors: [
         {
           messageId: 'useNamespace',
@@ -26,8 +26,8 @@ ruleTester.run('prefer-namespace-keyword', rule, {
       ],
     },
     {
-      code: 'declare module foo { }',
-      output: 'declare namespace foo { }',
+      code: 'declare module foo {}',
+      output: 'declare namespace foo {}',
       errors: [
         {
           messageId: 'useNamespace',
@@ -39,14 +39,14 @@ ruleTester.run('prefer-namespace-keyword', rule, {
     {
       code: `
 declare module foo {
-    declare module bar { }
+  declare module bar {}
 }
-            `,
+      `,
       output: `
 declare namespace foo {
-    declare namespace bar { }
+  declare namespace bar {}
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'useNamespace',
@@ -56,7 +56,7 @@ declare namespace foo {
         {
           messageId: 'useNamespace',
           line: 3,
-          column: 5,
+          column: 3,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/prefer-optional-chain.test.ts b/packages/eslint-plugin/tests/rules/prefer-optional-chain.test.ts
index ccd3e992cf0..eed61d687e4 100644
--- a/packages/eslint-plugin/tests/rules/prefer-optional-chain.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-optional-chain.test.ts
@@ -1,5 +1,5 @@
 import rule from '../../src/rules/prefer-optional-chain';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 import { TSESLint } from '@typescript-eslint/experimental-utils';
 import {
   InferMessageIdsTypeFromRule,
@@ -116,23 +116,23 @@ const baseCases = [
 
 ruleTester.run('prefer-optional-chain', rule, {
   valid: [
-    'foo && bar',
-    'foo && foo',
-    'foo || bar',
-    'foo ?? bar',
-    'foo || foo.bar',
-    'foo ?? foo.bar',
-    "file !== 'index.ts' && file.endsWith('.ts')",
-    'nextToken && sourceCode.isSpaceBetweenTokens(prevToken, nextToken)',
-    'result && this.options.shouldPreserveNodeMaps',
-    'foo && fooBar.baz',
-    'match && match$1 !== undefined',
-    'foo !== null && foo !== undefined',
-    'x["y"] !== undefined && x["y"] !== null',
+    'foo && bar;',
+    'foo && foo;',
+    'foo || bar;',
+    'foo ?? bar;',
+    'foo || foo.bar;',
+    'foo ?? foo.bar;',
+    "file !== 'index.ts' && file.endsWith('.ts');",
+    'nextToken && sourceCode.isSpaceBetweenTokens(prevToken, nextToken);',
+    'result && this.options.shouldPreserveNodeMaps;',
+    'foo && fooBar.baz;',
+    'match && match$1 !== undefined;',
+    'foo !== null && foo !== undefined;',
+    "x['y'] !== undefined && x['y'] !== null;",
     // currently do not handle complex computed properties
-    'foo && foo[bar as string] && foo[bar as string].baz',
-    'foo && foo[1 + 2] && foo[1 + 2].baz',
-    'foo && foo[typeof bar] && foo[typeof bar].baz',
+    'foo && foo[bar as string] && foo[bar as string].baz;',
+    'foo && foo[1 + 2] && foo[1 + 2].baz;',
+    'foo && foo[typeof bar] && foo[typeof bar].baz;',
   ],
   invalid: [
     ...baseCases,
@@ -176,8 +176,8 @@ ruleTester.run('prefer-optional-chain', rule, {
     {
       // case with inconsistent checks
       code:
-        'foo && foo.bar != null && foo.bar.baz !== undefined && foo.bar.baz.buzz',
-      output: 'foo?.bar?.baz?.buzz',
+        'foo && foo.bar != null && foo.bar.baz !== undefined && foo.bar.baz.buzz;',
+      output: 'foo?.bar?.baz?.buzz;',
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -186,8 +186,8 @@ ruleTester.run('prefer-optional-chain', rule, {
     },
     // ensure essential whitespace isn't removed
     {
-      code: 'foo && foo.bar(baz => (<This Requires Spaces />));',
-      output: 'foo?.bar(baz => (<This Requires Spaces />));',
+      code: 'foo && foo.bar(baz => <This Requires Spaces />);',
+      output: 'foo?.bar(baz => <This Requires Spaces />);',
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -209,8 +209,8 @@ ruleTester.run('prefer-optional-chain', rule, {
       ],
     },
     {
-      code: 'foo && foo["some long string"] && foo["some long string"].baz',
-      output: 'foo?.["some long string"]?.baz',
+      code: noFormat`foo && foo["some long string"] && foo["some long string"].baz`,
+      output: noFormat`foo?.["some long string"]?.baz`,
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -218,8 +218,8 @@ ruleTester.run('prefer-optional-chain', rule, {
       ],
     },
     {
-      code: 'foo && foo[`some long string`] && foo[`some long string`].baz',
-      output: 'foo?.[`some long string`]?.baz',
+      code: noFormat`foo && foo[\`some long string\`] && foo[\`some long string\`].baz`,
+      output: noFormat`foo?.[\`some long string\`]?.baz`,
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -227,8 +227,8 @@ ruleTester.run('prefer-optional-chain', rule, {
       ],
     },
     {
-      code: "foo && foo['some long string'] && foo['some long string'].baz",
-      output: "foo?.['some long string']?.baz",
+      code: "foo && foo['some long string'] && foo['some long string'].baz;",
+      output: "foo?.['some long string']?.baz;",
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -237,12 +237,12 @@ ruleTester.run('prefer-optional-chain', rule, {
     },
     // should preserve comments in a call expression
     {
-      code: `
+      code: noFormat`
         foo && foo.bar(/* comment */a,
           // comment2
           b, );
       `,
-      output: `
+      output: noFormat`
         foo?.bar(/* comment */a,
           // comment2
           b, );
@@ -255,8 +255,8 @@ ruleTester.run('prefer-optional-chain', rule, {
     },
     // ensure binary expressions that are the last expression do not get removed
     {
-      code: 'foo && foo.bar != null',
-      output: 'foo?.bar != null',
+      code: 'foo && foo.bar != null;',
+      output: 'foo?.bar != null;',
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -264,8 +264,8 @@ ruleTester.run('prefer-optional-chain', rule, {
       ],
     },
     {
-      code: 'foo && foo.bar != undefined',
-      output: 'foo?.bar != undefined',
+      code: 'foo && foo.bar != undefined;',
+      output: 'foo?.bar != undefined;',
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -273,8 +273,8 @@ ruleTester.run('prefer-optional-chain', rule, {
       ],
     },
     {
-      code: 'foo && foo.bar != null && baz',
-      output: 'foo?.bar != null && baz',
+      code: 'foo && foo.bar != null && baz;',
+      output: 'foo?.bar != null && baz;',
       errors: [
         {
           messageId: 'preferOptionalChain',
@@ -283,8 +283,8 @@ ruleTester.run('prefer-optional-chain', rule, {
     },
     // other weird cases
     {
-      code: 'foo && foo?.()',
-      output: 'foo?.()',
+      code: 'foo && foo?.();',
+      output: 'foo?.();',
       errors: [
         {
           messageId: 'preferOptionalChain',
diff --git a/packages/eslint-plugin/tests/rules/prefer-readonly-parameter-types.test.ts b/packages/eslint-plugin/tests/rules/prefer-readonly-parameter-types.test.ts
index 32caf683c77..3ca6c0201fc 100644
--- a/packages/eslint-plugin/tests/rules/prefer-readonly-parameter-types.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-readonly-parameter-types.test.ts
@@ -72,7 +72,10 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
       function foo(arg: typeof symb) {}
     `,
     `
-      enum Enum { a, b }
+      enum Enum {
+        a,
+        b,
+      }
       function foo(arg: Enum) {}
     `,
 
@@ -97,19 +100,15 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     `
       function foo(arg: {
         readonly foo: {
-          readonly bar: string
-        }
+          readonly bar: string;
+        };
       }) {}
     `,
     `
-      function foo(arg: {
-        readonly [k: string]: string,
-      }) {}
+      function foo(arg: { readonly [k: string]: string }) {}
     `,
     `
-      function foo(arg: {
-        readonly [k: number]: string,
-      }) {}
+      function foo(arg: { readonly [k: number]: string }) {}
     `,
     `
       interface Empty {}
@@ -120,13 +119,13 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     ...weirdIntersections.map(code => code),
     `
       interface Test extends ReadonlyArray<string> {
-        readonly property: boolean
+        readonly property: boolean;
       }
       function foo(arg: Readonly<Test>) {}
     `,
     `
-      type Test = (readonly string[]) & {
-        readonly property: boolean
+      type Test = readonly string[] & {
+        readonly property: boolean;
       };
       function foo(arg: Readonly<Test>) {}
     `,
@@ -193,12 +192,24 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     },
 
     // type functions
-    'interface Foo { (arg: readonly string[]): void }', // TSCallSignatureDeclaration
-    'interface Foo { new (arg: readonly string[]): void }', // TSConstructSignatureDeclaration
-    'const x = { foo(arg: readonly string[]): void }', // TSEmptyBodyFunctionExpression
+    `
+      interface Foo {
+        (arg: readonly string[]): void;
+      }
+    `, // TSCallSignatureDeclaration
+    `
+      interface Foo {
+        new (arg: readonly string[]): void;
+      }
+    `, // TSConstructSignatureDeclaration
+    'const x = { foo(arg: readonly string[]): void; };', // TSEmptyBodyFunctionExpression
     'function foo(arg: readonly string[]);', // TSDeclareFunction
     'type Foo = (arg: readonly string[]) => void;', // TSFunctionType
-    'interface Foo { foo(arg: readonly string[]): void }', // TSMethodSignature
+    `
+      interface Foo {
+        foo(arg: readonly string[]): void;
+      }
+    `, // TSMethodSignature
 
     // https://github.com/typescript-eslint/typescript-eslint/issues/1665
     // directly recursive
@@ -248,12 +259,12 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     }),
     // nested arrays
     {
-      code: 'function foo(arg: readonly (string[])[]) {}',
+      code: 'function foo(arg: readonly string[][]) {}',
       errors: [
         {
           messageId: 'shouldBeReadonly',
           column: 14,
-          endColumn: 40,
+          endColumn: 38,
         },
       ],
     },
@@ -295,8 +306,8 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
       code: `
         function foo(arg: {
           readonly foo: {
-            bar: string
-          }
+            bar: string;
+          };
         }) {}
       `,
       errors: [
@@ -312,33 +323,29 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     // object index signatures
     {
       code: `
-        function foo(arg: {
-          [key: string]: string
-        }) {}
+        function foo(arg: { [key: string]: string }) {}
       `,
       errors: [
         {
           messageId: 'shouldBeReadonly',
           line: 2,
           column: 22,
-          endLine: 4,
-          endColumn: 10,
+          endLine: 2,
+          endColumn: 52,
         },
       ],
     },
     {
       code: `
-        function foo(arg: {
-          [key: number]: string
-        }) {}
+        function foo(arg: { [key: number]: string }) {}
       `,
       errors: [
         {
           messageId: 'shouldBeReadonly',
           line: 2,
           column: 22,
-          endLine: 4,
-          endColumn: 10,
+          endLine: 2,
+          endColumn: 52,
         },
       ],
     },
@@ -356,7 +363,7 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     {
       code: `
         interface Test extends Array<string> {
-          readonly property: boolean
+          readonly property: boolean;
         }
         function foo(arg: Test) {}
       `,
@@ -373,7 +380,7 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     {
       code: `
         interface Test extends Array<string> {
-          property: boolean
+          property: boolean;
         }
         function foo(arg: Test) {}
       `,
@@ -393,10 +400,10 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
       code: `
         class Foo {
           constructor(
-            private   arg1: string[],
-            public    arg2: string[],
+            private arg1: string[],
+            public arg2: string[],
             protected arg3: string[],
-            readonly  arg4: string[],
+            readonly arg4: string[],
           ) {}
         }
       `,
@@ -409,16 +416,16 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
         {
           messageId: 'shouldBeReadonly',
           line: 4,
-          column: 23,
+          column: 21,
           endLine: 4,
-          endColumn: 37,
+          endColumn: 35,
         },
         {
           messageId: 'shouldBeReadonly',
           line: 5,
-          column: 23,
+          column: 20,
           endLine: 5,
-          endColumn: 37,
+          endColumn: 34,
         },
         {
           messageId: 'shouldBeReadonly',
@@ -430,9 +437,9 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
         {
           messageId: 'shouldBeReadonly',
           line: 7,
-          column: 23,
+          column: 22,
           endLine: 7,
-          endColumn: 37,
+          endColumn: 36,
         },
       ],
     },
@@ -440,10 +447,10 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
       code: `
         class Foo {
           constructor(
-            private   arg1: readonly string[],
-            public    arg2: readonly string[],
+            private arg1: readonly string[],
+            public arg2: readonly string[],
             protected arg3: readonly string[],
-            readonly  arg4: readonly string[],
+            readonly arg4: readonly string[],
             arg5: string[],
           ) {}
         }
@@ -467,29 +474,37 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     // type functions
     {
       // TSCallSignatureDeclaration
-      code: 'interface Foo { (arg: string[]): void }',
+      code: `
+        interface Foo {
+          (arg: string[]): void;
+        }
+      `,
       errors: [
         {
           messageId: 'shouldBeReadonly',
-          column: 18,
-          endColumn: 31,
+          column: 12,
+          endColumn: 25,
         },
       ],
     },
     {
       // TSConstructSignatureDeclaration
-      code: 'interface Foo { new (arg: string[]): void }',
+      code: `
+        interface Foo {
+          new (arg: string[]): void;
+        }
+      `,
       errors: [
         {
           messageId: 'shouldBeReadonly',
-          column: 22,
-          endColumn: 35,
+          column: 16,
+          endColumn: 29,
         },
       ],
     },
     {
       // TSEmptyBodyFunctionExpression
-      code: 'const x = { foo(arg: string[]): void }',
+      code: 'const x = { foo(arg: string[]): void; };',
       errors: [
         {
           messageId: 'shouldBeReadonly',
@@ -511,7 +526,7 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     },
     {
       // TSFunctionType
-      code: 'type Foo = (arg: string[]) => void',
+      code: 'type Foo = (arg: string[]) => void;',
       errors: [
         {
           messageId: 'shouldBeReadonly',
@@ -522,12 +537,16 @@ ruleTester.run('prefer-readonly-parameter-types', rule, {
     },
     {
       // TSMethodSignature
-      code: 'interface Foo { foo(arg: string[]): void }',
+      code: `
+        interface Foo {
+          foo(arg: string[]): void;
+        }
+      `,
       errors: [
         {
           messageId: 'shouldBeReadonly',
-          column: 21,
-          endColumn: 34,
+          column: 15,
+          endColumn: 28,
         },
       ],
     },
diff --git a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
index 256e38360d9..43ecdb03fe8 100644
--- a/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-readonly.test.ts
@@ -13,217 +13,275 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('prefer-readonly', rule, {
   valid: [
-    'function ignore() { }',
-    'const ignore = function () { }',
-    'const ignore = () => { }',
-    `const container = { member: true };
-      container.member;`,
-    `const container = { member: 1 };
-      +container.member;`,
-    `const container = { member: 1 };
-      ++container.member;`,
-    `const container = { member: 1 };
-      container.member++;`,
-    `const container = { member: 1 };
-      -container.member;`,
-    `const container = { member: 1 };
-      --container.member;`,
-    `const container = { member: 1 };
-      container.member--;`,
-    'class TestEmpty { }',
-    `class TestReadonlyStatic {
-      private static readonly correctlyReadonlyStatic = 7;
-    }`,
-    `class TestModifiableStatic {
-      private static correctlyModifiableStatic = 7;
-
-      public constructor() {
-        TestModifiableStatic.correctlyModifiableStatic += 1;
+    'function ignore() {}',
+    'const ignore = function() {};',
+    'const ignore = () => {};',
+    `
+      const container = { member: true };
+      container.member;
+    `,
+    `
+      const container = { member: 1 };
+      +container.member;
+    `,
+    `
+      const container = { member: 1 };
+      ++container.member;
+    `,
+    `
+      const container = { member: 1 };
+      container.member++;
+    `,
+    `
+      const container = { member: 1 };
+      -container.member;
+    `,
+    `
+      const container = { member: 1 };
+      --container.member;
+    `,
+    `
+      const container = { member: 1 };
+      container.member--;
+    `,
+    'class TestEmpty {}',
+    `
+      class TestReadonlyStatic {
+        private static readonly correctlyReadonlyStatic = 7;
       }
-    }`,
-    `class TestModifiableByParameterProperty {
-      private static readonly correctlyModifiableByParameterProperty = 7;
-
-      public constructor(
-        public correctlyModifiablePublicParameter: number = (() => {
-          return TestModifiableStatic.correctlyModifiableByParameterProperty += 1;
-        })()
-      ) { }
-    }`,
-    `class TestReadonlyInline {
-      private readonly correctlyReadonlyInline = 7;
-    }`,
-    `class TestReadonlyDelayed {
-      private readonly correctlyReadonlyDelayed = 7;
-
-      public constructor() {
-        this.correctlyReadonlyDelayed += 1;
+    `,
+    `
+      class TestModifiableStatic {
+        private static correctlyModifiableStatic = 7;
+
+        public constructor() {
+          TestModifiableStatic.correctlyModifiableStatic += 1;
+        }
       }
-    }`,
-    `class TestModifiableInline {
-      private correctlyModifiableInline = 7;
+    `,
+    `
+      class TestModifiableByParameterProperty {
+        private static readonly correctlyModifiableByParameterProperty = 7;
 
-      public mutate() {
-        this.correctlyModifiableInline += 1;
+        public constructor(
+          public correctlyModifiablePublicParameter: number = (() => {
+            return (TestModifiableStatic.correctlyModifiableByParameterProperty += 1);
+          })(),
+        ) {}
+      }
+    `,
+    `
+      class TestReadonlyInline {
+        private readonly correctlyReadonlyInline = 7;
+      }
+    `,
+    `
+      class TestReadonlyDelayed {
+        private readonly correctlyReadonlyDelayed = 7;
 
-        return class {
-          private correctlyModifiableInline = 7;
+        public constructor() {
+          this.correctlyReadonlyDelayed += 1;
+        }
+      }
+    `,
+    `
+      class TestModifiableInline {
+        private correctlyModifiableInline = 7;
 
-          mutate() {
-            this.correctlyModifiableInline += 1;
-          }
-        };
+        public mutate() {
+          this.correctlyModifiableInline += 1;
+
+          return class {
+            private correctlyModifiableInline = 7;
+
+            mutate() {
+              this.correctlyModifiableInline += 1;
+            }
+          };
+        }
       }
-    }`,
-    `class TestModifiableDelayed {
-      private correctlyModifiableDelayed = 7;
+    `,
+    `
+      class TestModifiableDelayed {
+        private correctlyModifiableDelayed = 7;
 
-      public mutate() {
-        this.correctlyModifiableDelayed += 1;
+        public mutate() {
+          this.correctlyModifiableDelayed += 1;
+        }
       }
-    }`,
-    `class TestModifiableDeleted {
-      private correctlyModifiableDeleted = 7;
+    `,
+    `
+      class TestModifiableDeleted {
+        private correctlyModifiableDeleted = 7;
 
-      public mutate() {
-        delete this.correctlyModifiableDeleted;
+        public mutate() {
+          delete this.correctlyModifiableDeleted;
+        }
       }
-    }`,
-    `class TestModifiableWithinConstructor {
-      private correctlyModifiableWithinConstructor = 7;
-
-      public constructor() {
-        (() => {
-          this.correctlyModifiableWithinConstructor += 1;
-        })();
+    `,
+    `
+      class TestModifiableWithinConstructor {
+        private correctlyModifiableWithinConstructor = 7;
+
+        public constructor() {
+          (() => {
+            this.correctlyModifiableWithinConstructor += 1;
+          })();
+        }
       }
-    }`,
-    `class TestModifiableWithinConstructorArrowFunction {
-      private correctlyModifiableWithinConstructorArrowFunction = 7;
-
-      public constructor() {
-        (() => {
-          this.correctlyModifiableWithinConstructorArrowFunction += 1;
-        })();
+    `,
+    `
+      class TestModifiableWithinConstructorArrowFunction {
+        private correctlyModifiableWithinConstructorArrowFunction = 7;
+
+        public constructor() {
+          (() => {
+            this.correctlyModifiableWithinConstructorArrowFunction += 1;
+          })();
+        }
       }
-    }`,
-    `class TestModifiableWithinConstructorInFunctionExpression {
-      private correctlyModifiableWithinConstructorInFunctionExpression = 7;
+    `,
+    `
+      class TestModifiableWithinConstructorInFunctionExpression {
+        private correctlyModifiableWithinConstructorInFunctionExpression = 7;
 
-      public constructor() {
-        const self = this;
+        public constructor() {
+          const self = this;
 
-        (() => {
-          self.correctlyModifiableWithinConstructorInFunctionExpression += 1;
-        })();
+          (() => {
+            self.correctlyModifiableWithinConstructorInFunctionExpression += 1;
+          })();
+        }
       }
-    }`,
-    `class TestModifiableWithinConstructorInGetAccessor {
-      private correctlyModifiableWithinConstructorInGetAccessor = 7;
+    `,
+    `
+      class TestModifiableWithinConstructorInGetAccessor {
+        private correctlyModifiableWithinConstructorInGetAccessor = 7;
 
-      public constructor() {
-        const self = this;
+        public constructor() {
+          const self = this;
 
-        const confusingObject = {
-          get accessor() {
-            return self.correctlyModifiableWithinConstructorInGetAccessor += 1;
-          },
-        };
+          const confusingObject = {
+            get accessor() {
+              return (self.correctlyModifiableWithinConstructorInGetAccessor += 1);
+            },
+          };
+        }
       }
-    }`,
-    `class TestModifiableWithinConstructorInMethodDeclaration {
-      private correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+    `,
+    `
+      class TestModifiableWithinConstructorInMethodDeclaration {
+        private correctlyModifiableWithinConstructorInMethodDeclaration = 7;
 
-      public constructor() {
-        const self = this;
+        public constructor() {
+          const self = this;
 
-        const confusingObject = {
-          methodDeclaration() {
-            self.correctlyModifiableWithinConstructorInMethodDeclaration = 7;
-          }
-      };
+          const confusingObject = {
+            methodDeclaration() {
+              self.correctlyModifiableWithinConstructorInMethodDeclaration = 7;
+            },
+          };
+        }
       }
-    }`,
-    `class TestModifiableWithinConstructorInSetAccessor {
-      private correctlyModifiableWithinConstructorInSetAccessor = 7;
+    `,
+    `
+      class TestModifiableWithinConstructorInSetAccessor {
+        private correctlyModifiableWithinConstructorInSetAccessor = 7;
 
-      public constructor() {
-        const self = this;
+        public constructor() {
+          const self = this;
 
-        const confusingObject = {
-          set accessor(value: number) {
-            self.correctlyModifiableWithinConstructorInSetAccessor += value;
-          },
-        };
+          const confusingObject = {
+            set accessor(value: number) {
+              self.correctlyModifiableWithinConstructorInSetAccessor += value;
+            },
+          };
+        }
       }
-    }`,
-    `class TestModifiablePostDecremented {
-      private correctlyModifiablePostDecremented = 7;
+    `,
+    `
+      class TestModifiablePostDecremented {
+        private correctlyModifiablePostDecremented = 7;
 
-      public mutate() {
-        this.correctlyModifiablePostDecremented -= 1;
+        public mutate() {
+          this.correctlyModifiablePostDecremented -= 1;
+        }
       }
-    }`,
-    `class TestyModifiablePostIncremented {
-      private correctlyModifiablePostIncremented = 7;
+    `,
+    `
+      class TestyModifiablePostIncremented {
+        private correctlyModifiablePostIncremented = 7;
 
-      public mutate() {
-        this.correctlyModifiablePostIncremented += 1;
+        public mutate() {
+          this.correctlyModifiablePostIncremented += 1;
+        }
       }
-    }`,
-    `class TestModifiablePreDecremented {
-      private correctlyModifiablePreDecremented = 7;
+    `,
+    `
+      class TestModifiablePreDecremented {
+        private correctlyModifiablePreDecremented = 7;
 
-      public mutate() {
-        --this.correctlyModifiablePreDecremented;
+        public mutate() {
+          --this.correctlyModifiablePreDecremented;
+        }
       }
-    }`,
-    `class TestModifiablePreIncremented {
-      private correctlyModifiablePreIncremented = 7;
+    `,
+    `
+      class TestModifiablePreIncremented {
+        private correctlyModifiablePreIncremented = 7;
 
-      public mutate() {
-        ++this.correctlyModifiablePreIncremented;
+        public mutate() {
+          ++this.correctlyModifiablePreIncremented;
+        }
+      }
+    `,
+    `
+      class TestProtectedModifiable {
+        protected protectedModifiable = 7;
+      }
+    `,
+    `
+      class TestPublicModifiable {
+        public publicModifiable = 7;
+      }
+    `,
+    `
+      class TestReadonlyParameter {
+        public constructor(private readonly correctlyReadonlyParameter = 7) {}
       }
-    }`,
-    `class TestProtectedModifiable {
-      protected protectedModifiable = 7;
-    }`,
-    `class TestPublicModifiable {
-      public publicModifiable = 7;
-    }`,
-    `class TestReadonlyParameter {
-      public constructor(
-        private readonly correctlyReadonlyParameter = 7,
-      ) { }
-    }`,
-    `class TestCorrectlyModifiableParameter {
-      public constructor(
-        private correctlyModifiableParameter = 7,
-      ) { }
-
-      public mutate() {
-        this.correctlyModifiableParameter += 1;
+    `,
+    `
+      class TestCorrectlyModifiableParameter {
+        public constructor(private correctlyModifiableParameter = 7) {}
+
+        public mutate() {
+          this.correctlyModifiableParameter += 1;
+        }
       }
-    }`,
+    `,
     {
-      code: `class TestCorrectlyNonInlineLambdas {
-        private correctlyNonInlineLambda = 7;
-      }`,
+      code: `
+        class TestCorrectlyNonInlineLambdas {
+          private correctlyNonInlineLambda = 7;
+        }
+      `,
       options: [
         {
           onlyInlineLambdas: true,
         },
       ],
     },
-    `class TestComputedParameter {
-      public mutate() {
-        this['computed'] = 1;
+    `
+      class TestComputedParameter {
+        public mutate() {
+          this['computed'] = 1;
+        }
       }
-    }`,
+    `,
     {
       code: `
 class Foo {
-  private value: number = 0
+  private value: number = 0;
 
   bar(newValue: { value: number }) {
     ({ value: this.value } = newValue);
@@ -247,7 +305,7 @@ class Foo {
     {
       code: `
 class Foo {
-  private value: number[] = []
+  private value: number[] = [];
 
   bar(newValue: number[]) {
     [...this.value] = newValue;
@@ -271,9 +329,11 @@ class Foo {
   ],
   invalid: [
     {
-      code: `class TestIncorrectlyModifiableStatic {
-        private static incorrectlyModifiableStatic = 7;
-      }`,
+      code: `
+        class TestIncorrectlyModifiableStatic {
+          private static incorrectlyModifiableStatic = 7;
+        }
+      `,
       errors: [
         {
           data: {
@@ -282,14 +342,18 @@ class Foo {
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiableStatic {
-        private static readonly incorrectlyModifiableStatic = 7;
-      }`,
+      output: `
+        class TestIncorrectlyModifiableStatic {
+          private static readonly incorrectlyModifiableStatic = 7;
+        }
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiableStaticArrow {
-        private static incorrectlyModifiableStaticArrow = () => 7;
-      }`,
+      code: `
+        class TestIncorrectlyModifiableStaticArrow {
+          private static incorrectlyModifiableStaticArrow = () => 7;
+        }
+      `,
       errors: [
         {
           data: {
@@ -298,54 +362,62 @@ class Foo {
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiableStaticArrow {
-        private static readonly incorrectlyModifiableStaticArrow = () => 7;
-      }`,
+      output: `
+        class TestIncorrectlyModifiableStaticArrow {
+          private static readonly incorrectlyModifiableStaticArrow = () => 7;
+        }
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiableInline {
-        private incorrectlyModifiableInline = 7;
+      code: `
+        class TestIncorrectlyModifiableInline {
+          private incorrectlyModifiableInline = 7;
 
-        public createConfusingChildClass() {
-          return class {
+          public createConfusingChildClass() {
+            return class {
               private incorrectlyModifiableInline = 7;
+            };
           }
         }
-      }`,
+      `,
       errors: [
         {
           data: {
             name: 'incorrectlyModifiableInline',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
         {
           data: {
             name: 'incorrectlyModifiableInline',
           },
-          line: 6,
+          line: 7,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiableInline {
-        private readonly incorrectlyModifiableInline = 7;
+      output: `
+        class TestIncorrectlyModifiableInline {
+          private readonly incorrectlyModifiableInline = 7;
 
-        public createConfusingChildClass() {
-          return class {
+          public createConfusingChildClass() {
+            return class {
               private readonly incorrectlyModifiableInline = 7;
+            };
           }
         }
-      }`,
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiableDelayed {
-        private incorrectlyModifiableDelayed = 7;
+      code: `
+        class TestIncorrectlyModifiableDelayed {
+          private incorrectlyModifiableDelayed = 7;
 
-        public constructor() {
-          this.incorrectlyModifiableDelayed = 7;
+          public constructor() {
+            this.incorrectlyModifiableDelayed = 7;
+          }
         }
-      }`,
+      `,
       errors: [
         {
           data: {
@@ -354,190 +426,216 @@ class Foo {
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiableDelayed {
-        private readonly incorrectlyModifiableDelayed = 7;
+      output: `
+        class TestIncorrectlyModifiableDelayed {
+          private readonly incorrectlyModifiableDelayed = 7;
 
-        public constructor() {
-          this.incorrectlyModifiableDelayed = 7;
+          public constructor() {
+            this.incorrectlyModifiableDelayed = 7;
+          }
         }
-      }`,
+      `,
     },
     {
-      code: `class TestChildClassExpressionModifiable {
-        private childClassExpressionModifiable = 7;
+      code: `
+        class TestChildClassExpressionModifiable {
+          private childClassExpressionModifiable = 7;
 
-        public createConfusingChildClass() {
-          return class {
-            private childClassExpressionModifiable = 7;
+          public createConfusingChildClass() {
+            return class {
+              private childClassExpressionModifiable = 7;
 
-            mutate() {
-              this.childClassExpressionModifiable += 1;
-            }
+              mutate() {
+                this.childClassExpressionModifiable += 1;
+              }
+            };
           }
         }
-      }`,
+      `,
       errors: [
         {
           data: {
             name: 'childClassExpressionModifiable',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestChildClassExpressionModifiable {
-        private readonly childClassExpressionModifiable = 7;
-
-        public createConfusingChildClass() {
-          return class {
-            private childClassExpressionModifiable = 7;
-
-            mutate() {
-              this.childClassExpressionModifiable += 1;
-            }
+      output: `
+        class TestChildClassExpressionModifiable {
+          private readonly childClassExpressionModifiable = 7;
+
+          public createConfusingChildClass() {
+            return class {
+              private childClassExpressionModifiable = 7;
+
+              mutate() {
+                this.childClassExpressionModifiable += 1;
+              }
+            };
           }
         }
-      }`,
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiablePostMinus {
-        private incorrectlyModifiablePostMinus = 7;
+      code: `
+        class TestIncorrectlyModifiablePostMinus {
+          private incorrectlyModifiablePostMinus = 7;
 
-        public mutate() {
-          this.incorrectlyModifiablePostMinus - 1;
+          public mutate() {
+            this.incorrectlyModifiablePostMinus - 1;
+          }
         }
-      }`,
+      `,
       errors: [
         {
           data: {
             name: 'incorrectlyModifiablePostMinus',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiablePostMinus {
-        private readonly incorrectlyModifiablePostMinus = 7;
+      output: `
+        class TestIncorrectlyModifiablePostMinus {
+          private readonly incorrectlyModifiablePostMinus = 7;
 
-        public mutate() {
-          this.incorrectlyModifiablePostMinus - 1;
+          public mutate() {
+            this.incorrectlyModifiablePostMinus - 1;
+          }
         }
-      }`,
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiablePostPlus {
-        private incorrectlyModifiablePostPlus = 7;
+      code: `
+        class TestIncorrectlyModifiablePostPlus {
+          private incorrectlyModifiablePostPlus = 7;
 
-        public mutate() {
-          this.incorrectlyModifiablePostPlus + 1;
+          public mutate() {
+            this.incorrectlyModifiablePostPlus + 1;
+          }
         }
-      }`,
+      `,
       errors: [
         {
           data: {
             name: 'incorrectlyModifiablePostPlus',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiablePostPlus {
-        private readonly incorrectlyModifiablePostPlus = 7;
+      output: `
+        class TestIncorrectlyModifiablePostPlus {
+          private readonly incorrectlyModifiablePostPlus = 7;
 
-        public mutate() {
-          this.incorrectlyModifiablePostPlus + 1;
+          public mutate() {
+            this.incorrectlyModifiablePostPlus + 1;
+          }
         }
-      }`,
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiablePreMinus {
-        private incorrectlyModifiablePreMinus = 7;
+      code: `
+        class TestIncorrectlyModifiablePreMinus {
+          private incorrectlyModifiablePreMinus = 7;
 
-        public mutate() {
-          -this.incorrectlyModifiablePreMinus;
+          public mutate() {
+            -this.incorrectlyModifiablePreMinus;
+          }
         }
-      }`,
+      `,
       errors: [
         {
           data: {
             name: 'incorrectlyModifiablePreMinus',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiablePreMinus {
-        private readonly incorrectlyModifiablePreMinus = 7;
+      output: `
+        class TestIncorrectlyModifiablePreMinus {
+          private readonly incorrectlyModifiablePreMinus = 7;
 
-        public mutate() {
-          -this.incorrectlyModifiablePreMinus;
+          public mutate() {
+            -this.incorrectlyModifiablePreMinus;
+          }
         }
-      }`,
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiablePrePlus {
-        private incorrectlyModifiablePrePlus = 7;
+      code: `
+        class TestIncorrectlyModifiablePrePlus {
+          private incorrectlyModifiablePrePlus = 7;
 
-        public mutate() {
-          +this.incorrectlyModifiablePrePlus;
+          public mutate() {
+            +this.incorrectlyModifiablePrePlus;
+          }
         }
-      }`,
+      `,
       errors: [
         {
           data: {
             name: 'incorrectlyModifiablePrePlus',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiablePrePlus {
-        private readonly incorrectlyModifiablePrePlus = 7;
+      output: `
+        class TestIncorrectlyModifiablePrePlus {
+          private readonly incorrectlyModifiablePrePlus = 7;
 
-        public mutate() {
-          +this.incorrectlyModifiablePrePlus;
+          public mutate() {
+            +this.incorrectlyModifiablePrePlus;
+          }
         }
-      }`,
+      `,
     },
     {
-      code: `class TestOverlappingClassVariable {
-        private overlappingClassVariable = 7;
+      code: `
+        class TestOverlappingClassVariable {
+          private overlappingClassVariable = 7;
 
-        public workWithSimilarClass(other: SimilarClass) {
-          other.overlappingClassVariable = 7;
+          public workWithSimilarClass(other: SimilarClass) {
+            other.overlappingClassVariable = 7;
+          }
         }
-      }
 
-      class SimilarClass {
-        public overlappingClassVariable = 7;
-      }`,
+        class SimilarClass {
+          public overlappingClassVariable = 7;
+        }
+      `,
       errors: [
         {
           data: {
             name: 'overlappingClassVariable',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestOverlappingClassVariable {
-        private readonly overlappingClassVariable = 7;
+      output: `
+        class TestOverlappingClassVariable {
+          private readonly overlappingClassVariable = 7;
 
-        public workWithSimilarClass(other: SimilarClass) {
-          other.overlappingClassVariable = 7;
+          public workWithSimilarClass(other: SimilarClass) {
+            other.overlappingClassVariable = 7;
+          }
         }
-      }
 
-      class SimilarClass {
-        public overlappingClassVariable = 7;
-      }`,
+        class SimilarClass {
+          public overlappingClassVariable = 7;
+        }
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiableParameter {
-        public constructor(
-          private incorrectlyModifiableParameter = 7,
-        ) { }
-      }`,
+      code: `
+        class TestIncorrectlyModifiableParameter {
+          public constructor(private incorrectlyModifiableParameter = 7) {}
+        }
+      `,
       errors: [
         {
           data: {
@@ -547,45 +645,51 @@ class Foo {
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiableParameter {
-        public constructor(
-          private readonly incorrectlyModifiableParameter = 7,
-        ) { }
-      }`,
+      output: `
+        class TestIncorrectlyModifiableParameter {
+          public constructor(private readonly incorrectlyModifiableParameter = 7) {}
+        }
+      `,
     },
     {
-      code: `class TestIncorrectlyModifiableParameter {
-        public constructor(
-          public ignore: boolean,
-          private incorrectlyModifiableParameter = 7,
-        ) { }
-      }`,
+      code: `
+        class TestIncorrectlyModifiableParameter {
+          public constructor(
+            public ignore: boolean,
+            private incorrectlyModifiableParameter = 7,
+          ) {}
+        }
+      `,
       errors: [
         {
           data: {
             name: 'incorrectlyModifiableParameter',
           },
-          line: 4,
+          line: 5,
           messageId: 'preferReadonly',
         },
       ],
-      output: `class TestIncorrectlyModifiableParameter {
-        public constructor(
-          public ignore: boolean,
-          private readonly incorrectlyModifiableParameter = 7,
-        ) { }
-      }`,
+      output: `
+        class TestIncorrectlyModifiableParameter {
+          public constructor(
+            public ignore: boolean,
+            private readonly incorrectlyModifiableParameter = 7,
+          ) {}
+        }
+      `,
     },
     {
-      code: `class TestCorrectlyNonInlineLambdas {
-        private incorrectlyInlineLambda = () => 7;
-      }`,
+      code: `
+        class TestCorrectlyNonInlineLambdas {
+          private incorrectlyInlineLambda = () => 7;
+        }
+      `,
       errors: [
         {
           data: {
             name: 'incorrectlyInlineLambda',
           },
-          line: 2,
+          line: 3,
           messageId: 'preferReadonly',
         },
       ],
@@ -594,9 +698,11 @@ class Foo {
           onlyInlineLambdas: true,
         },
       ],
-      output: `class TestCorrectlyNonInlineLambdas {
-        private readonly incorrectlyInlineLambda = () => 7;
-      }`,
+      output: `
+        class TestCorrectlyNonInlineLambdas {
+          private readonly incorrectlyInlineLambda = () => 7;
+        }
+      `,
     },
   ],
 });
diff --git a/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts b/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
index 045c36206ee..fc97766f9f7 100644
--- a/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
+++ b/packages/eslint-plugin/tests/rules/prefer-regexp-exec.test.ts
@@ -13,30 +13,30 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('prefer-regexp-exec', rule, {
   valid: [
-    '"something".match();',
-    '"something".match(/thing/g);',
+    "'something'.match();",
+    "'something'.match(/thing/g);",
     `
-const text = "something";
+const text = 'something';
 const search = /thing/g;
 text.match(search);
-`,
+    `,
     `
-const match = (s: RegExp) => "something";
+const match = (s: RegExp) => 'something';
 match(/thing/);
-`,
+    `,
     `
-const a = {match : (s: RegExp) => "something"};
+const a = { match: (s: RegExp) => 'something' };
 a.match(/thing/);
-`,
+    `,
     `
 function f(s: string | string[]) {
   s.match(/e/);
 }
-`,
+    `,
   ],
   invalid: [
     {
-      code: '"something".match(/thing/);',
+      code: "'something'.match(/thing/);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -47,10 +47,10 @@ function f(s: string | string[]) {
     },
     {
       code: `
-const text = "something";
+const text = 'something';
 const search = /thing/;
 text.match(search);
-`,
+      `,
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -60,7 +60,7 @@ text.match(search);
       ],
     },
     {
-      code: '"212".match(2);',
+      code: "'212'.match(2);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -70,7 +70,7 @@ text.match(search);
       ],
     },
     {
-      code: '"212".match(+2);',
+      code: "'212'.match(+2);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -80,7 +80,7 @@ text.match(search);
       ],
     },
     {
-      code: '"oNaNo".match(NaN);',
+      code: "'oNaNo'.match(NaN);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -91,7 +91,7 @@ text.match(search);
     },
     {
       code:
-        '"Infinity contains -Infinity and +Infinity in JavaScript.".match(Infinity);',
+        "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(Infinity);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -102,7 +102,7 @@ text.match(search);
     },
     {
       code:
-        '"Infinity contains -Infinity and +Infinity in JavaScript.".match(+Infinity);',
+        "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(+Infinity);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -113,7 +113,7 @@ text.match(search);
     },
     {
       code:
-        '"Infinity contains -Infinity and +Infinity in JavaScript.".match(-Infinity);',
+        "'Infinity contains -Infinity and +Infinity in JavaScript.'.match(-Infinity);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -123,7 +123,7 @@ text.match(search);
       ],
     },
     {
-      code: '"void and null".match(null);',
+      code: "'void and null'.match(null);",
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -137,7 +137,7 @@ text.match(search);
 function f(s: 'a' | 'b') {
   s.match('a');
 }
-`,
+      `,
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -148,11 +148,11 @@ function f(s: 'a' | 'b') {
     },
     {
       code: `
-type SafeString = string & {__HTML_ESCAPED__: void}
+type SafeString = string & { __HTML_ESCAPED__: void };
 function f(s: SafeString) {
   s.match(/thing/);
 }
-`,
+      `,
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
@@ -163,10 +163,10 @@ function f(s: SafeString) {
     },
     {
       code: `
-function f<T extends "a" | "b">(s: T) {
+function f<T extends 'a' | 'b'>(s: T) {
   s.match(/thing/);
 }
-    `,
+      `,
       errors: [
         {
           messageId: 'regExpExecOverStringMatch',
diff --git a/packages/eslint-plugin/tests/rules/promise-function-async.test.ts b/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
index 66a65a21ffd..d4da6e3b66c 100644
--- a/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
+++ b/packages/eslint-plugin/tests/rules/promise-function-async.test.ts
@@ -19,13 +19,19 @@ ruleTester.run('promise-function-async', rule, {
 const nonAsyncNonPromiseArrowFunction = (n: number) => n;
     `,
     `
-function nonAsyncNonPromiseFunctionDeclaration(n: number) { return n; }
+function nonAsyncNonPromiseFunctionDeclaration(n: number) {
+  return n;
+}
     `,
     `
-const asyncPromiseFunctionExpressionA = async function(p: Promise<void>) { return p; };
+const asyncPromiseFunctionExpressionA = async function(p: Promise<void>) {
+  return p;
+};
     `,
     `
-const asyncPromiseFunctionExpressionB = async function() { return new Promise<void>(); };
+const asyncPromiseFunctionExpressionB = async function() {
+  return new Promise<void>();
+};
     `,
     `
 class Test {
@@ -75,13 +81,25 @@ const invalidAsyncModifiers = {
   },
   set asyncGetterFunc(p: () => Promise<void>) {
     return p;
-  }
-}
+  },
+};
     `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/227
-    `export function valid(n: number) { return n; }`,
-    `export default function invalid(n: number) { return n; }`,
-    `class Foo { constructor() { } }`,
+    `
+      export function valid(n: number) {
+        return n;
+      }
+    `,
+    `
+      export default function invalid(n: number) {
+        return n;
+      }
+    `,
+    `
+      class Foo {
+        constructor() {}
+      }
+    `,
     {
       code: `
 function returnsAny(): any {
@@ -116,7 +134,7 @@ interface Options {
 type Return = ReadableStream | Promise<void>;
 const foo = (options: Options): Return => {
   return options.stream ? asStream(options) : asPromise(options);
-}
+};
       `,
     },
     {
@@ -164,8 +182,10 @@ function returnsUnknown(): unknown {
     },
     {
       code: `
-const nonAsyncPromiseFunctionExpressionA = function(p: Promise<void>) { return p; };
-            `,
+const nonAsyncPromiseFunctionExpressionA = function(p: Promise<void>) {
+  return p;
+};
+      `,
       errors: [
         {
           messageId,
@@ -174,8 +194,10 @@ const nonAsyncPromiseFunctionExpressionA = function(p: Promise<void>) { return p
     },
     {
       code: `
-const nonAsyncPromiseFunctionExpressionB = function() { return new Promise<void>(); };
-            `,
+const nonAsyncPromiseFunctionExpressionB = function() {
+  return new Promise<void>();
+};
+      `,
       errors: [
         {
           messageId,
@@ -184,8 +206,10 @@ const nonAsyncPromiseFunctionExpressionB = function() { return new Promise<void>
     },
     {
       code: `
-function nonAsyncPromiseFunctionDeclarationA(p: Promise<void>) { return p; }
-            `,
+function nonAsyncPromiseFunctionDeclarationA(p: Promise<void>) {
+  return p;
+}
+      `,
       errors: [
         {
           messageId,
@@ -194,8 +218,10 @@ function nonAsyncPromiseFunctionDeclarationA(p: Promise<void>) { return p; }
     },
     {
       code: `
-function nonAsyncPromiseFunctionDeclarationB() { return new Promise<void>(); }
-            `,
+function nonAsyncPromiseFunctionDeclarationB() {
+  return new Promise<void>();
+}
+      `,
       errors: [
         {
           messageId,
@@ -205,7 +231,7 @@ function nonAsyncPromiseFunctionDeclarationB() { return new Promise<void>(); }
     {
       code: `
 const nonAsyncPromiseArrowFunctionA = (p: Promise<void>) => p;
-            `,
+      `,
       errors: [
         {
           messageId,
@@ -215,7 +241,7 @@ const nonAsyncPromiseArrowFunctionA = (p: Promise<void>) => p;
     {
       code: `
 const nonAsyncPromiseArrowFunctionB = () => new Promise<void>();
-            `,
+      `,
       errors: [
         {
           messageId,
@@ -233,7 +259,7 @@ class Test {
     return new Promise<void>();
   }
 }
-          `,
+      `,
       errors: [
         {
           line: 3,
@@ -247,9 +273,13 @@ class Test {
     },
     {
       code: `
-const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) { return p; };
+const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) {
+  return p;
+};
 
-function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) { return p; }
+function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) {
+  return p;
+}
 
 const nonAsyncPromiseArrowFunction = (p: Promise<void>) => p;
 
@@ -258,7 +288,7 @@ class Test {
     return p;
   }
 }
-`,
+      `,
       options: [
         {
           checkArrowFunctions: false,
@@ -270,20 +300,24 @@ class Test {
           messageId,
         },
         {
-          line: 4,
+          line: 6,
           messageId,
         },
         {
-          line: 9,
+          line: 13,
           messageId,
         },
       ],
     },
     {
       code: `
-const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) { return p; };
+const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) {
+  return p;
+};
 
-function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) { return p; }
+function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) {
+  return p;
+}
 
 const nonAsyncPromiseArrowFunction = (p: Promise<void>) => p;
 
@@ -292,7 +326,7 @@ class Test {
     return p;
   }
 }
-`,
+      `,
       options: [
         {
           checkFunctionDeclarations: false,
@@ -304,20 +338,24 @@ class Test {
           messageId,
         },
         {
-          line: 6,
+          line: 10,
           messageId,
         },
         {
-          line: 9,
+          line: 13,
           messageId,
         },
       ],
     },
     {
       code: `
-const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) { return p; };
+const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) {
+  return p;
+};
 
-function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) { return p; }
+function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) {
+  return p;
+}
 
 const nonAsyncPromiseArrowFunction = (p: Promise<void>) => p;
 
@@ -326,7 +364,7 @@ class Test {
     return p;
   }
 }
-`,
+      `,
       options: [
         {
           checkFunctionExpressions: false,
@@ -334,24 +372,28 @@ class Test {
       ],
       errors: [
         {
-          line: 4,
+          line: 6,
           messageId,
         },
         {
-          line: 6,
+          line: 10,
           messageId,
         },
         {
-          line: 9,
+          line: 13,
           messageId,
         },
       ],
     },
     {
       code: `
-const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) { return p; };
+const nonAsyncPromiseFunctionExpression = function(p: Promise<void>) {
+  return p;
+};
 
-function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) { return p; }
+function nonAsyncPromiseFunctionDeclaration(p: Promise<void>) {
+  return p;
+}
 
 const nonAsyncPromiseArrowFunction = (p: Promise<void>) => p;
 
@@ -360,7 +402,7 @@ class Test {
     return p;
   }
 }
-`,
+      `,
       options: [
         {
           checkMethodDeclarations: false,
@@ -372,21 +414,21 @@ class Test {
           messageId,
         },
         {
-          line: 4,
+          line: 6,
           messageId,
         },
         {
-          line: 6,
+          line: 10,
           messageId,
         },
       ],
     },
     {
       code: `
-class PromiseType { }
+class PromiseType {}
 
 const returnAllowedType = () => new PromiseType();
-`,
+      `,
       options: [
         {
           allowedPromiseNames: ['PromiseType'],
@@ -403,7 +445,9 @@ const returnAllowedType = () => new PromiseType();
       code: `
 interface SPromise<T> extends Promise<T> {}
 function foo(): Promise<string> | SPromise<boolean> {
-  return Math.random() > 0.5 ? Promise.resolve('value') : Promise.resolve(false);
+  return Math.random() > 0.5
+    ? Promise.resolve('value')
+    : Promise.resolve(false);
 }
       `,
       options: [
diff --git a/packages/eslint-plugin/tests/rules/quotes.test.ts b/packages/eslint-plugin/tests/rules/quotes.test.ts
index ad1487b8506..f7b56a73ba3 100644
--- a/packages/eslint-plugin/tests/rules/quotes.test.ts
+++ b/packages/eslint-plugin/tests/rules/quotes.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests quotes, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import rule from '../../src/rules/quotes';
 import { RuleTester } from '../RuleTester';
 
@@ -31,7 +36,7 @@ const useBacktick: any = {
 ruleTester.run('quotes', rule, {
   valid: [
     {
-      code: `declare module '*.html' {}`,
+      code: "declare module '*.html' {}",
       options: ['backtick'],
     },
     {
@@ -44,25 +49,25 @@ ruleTester.run('quotes', rule, {
     },
 
     /** ESLint */
-    `var foo = "bar";`,
+    'var foo = "bar";',
     {
-      code: `var foo = 'bar';`,
+      code: "var foo = 'bar';",
       options: ['single'],
     },
     {
-      code: `var foo = "bar";`,
+      code: 'var foo = "bar";',
       options: ['double'],
     },
     {
-      code: `var foo = 1;`,
+      code: 'var foo = 1;',
       options: ['single'],
     },
     {
-      code: `var foo = 1;`,
+      code: 'var foo = 1;',
       options: ['double'],
     },
     {
-      code: `var foo = "'";`,
+      code: 'var foo = "\'";',
       options: [
         'single',
         {
@@ -71,7 +76,7 @@ ruleTester.run('quotes', rule, {
       ],
     },
     {
-      code: `var foo = '"';`,
+      code: "var foo = '\"';",
       options: [
         'double',
         {
@@ -80,7 +85,7 @@ ruleTester.run('quotes', rule, {
       ],
     },
     {
-      code: `var foo = <>Hello world</>;`,
+      code: 'var foo = <>Hello world</>;',
       options: ['single'],
       parserOptions: {
         ecmaFeatures: {
@@ -89,7 +94,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <>Hello world</>;`,
+      code: 'var foo = <>Hello world</>;',
       options: ['double'],
       parserOptions: {
         ecmaFeatures: {
@@ -98,7 +103,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <>Hello world</>;`,
+      code: 'var foo = <>Hello world</>;',
       options: [
         'double',
         {
@@ -112,7 +117,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <>Hello world</>;`,
+      code: 'var foo = <>Hello world</>;',
       options: ['backtick'],
       parserOptions: {
         ecmaFeatures: {
@@ -121,7 +126,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <div>Hello world</div>;`,
+      code: 'var foo = <div>Hello world</div>;',
       options: ['single'],
       parserOptions: {
         ecmaFeatures: {
@@ -130,7 +135,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <div id="foo"></div>;`,
+      code: 'var foo = <div id="foo"></div>;',
       options: ['single'],
       parserOptions: {
         ecmaFeatures: {
@@ -139,7 +144,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <div>Hello world</div>;`,
+      code: 'var foo = <div>Hello world</div>;',
       options: ['double'],
       parserOptions: {
         ecmaFeatures: {
@@ -148,7 +153,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <div>Hello world</div>;`,
+      code: 'var foo = <div>Hello world</div>;',
       options: [
         'double',
         {
@@ -174,7 +179,7 @@ ruleTester.run('quotes', rule, {
       options: ['backtick'],
     },
     {
-      code: `var foo = 1;`,
+      code: 'var foo = 1;',
       options: ['backtick'],
     },
     {
@@ -187,7 +192,7 @@ ruleTester.run('quotes', rule, {
       ],
     },
     {
-      code: `var foo = <div id="foo"></div>;`,
+      code: 'var foo = <div id="foo"></div>;',
       options: ['backtick'],
       parserOptions: {
         ecmaFeatures: {
@@ -196,7 +201,7 @@ ruleTester.run('quotes', rule, {
       },
     },
     {
-      code: `var foo = <div>Hello world</div>;`,
+      code: 'var foo = <div>Hello world</div>;',
       options: ['backtick'],
       parserOptions: {
         ecmaFeatures: {
@@ -299,33 +304,33 @@ ruleTester.run('quotes', rule, {
 
     // `backtick` should not warn import/export sources.
     {
-      code: `import "a"; import 'b';`,
+      code: 'import "a"; import \'b\';',
       options: ['backtick'],
     },
     {
-      code: `import a from "a"; import b from 'b';`,
+      code: 'import a from "a"; import b from \'b\';',
       options: ['backtick'],
     },
     {
-      code: `export * from "a"; export * from 'b';`,
+      code: 'export * from "a"; export * from \'b\';',
       options: ['backtick'],
     },
     // `backtick` should not warn import with require.
     {
-      code: `import moment = require('moment');`,
+      code: "import moment = require('moment');",
       options: ['backtick'],
     },
     // `backtick` should not warn property/method names (not computed).
     {
-      code: `var obj = {"key0": 0, 'key1': 1};`,
+      code: 'var obj = {"key0": 0, \'key1\': 1};',
       options: ['backtick'],
     },
     {
-      code: `class Foo { 'bar'(){} }`,
+      code: "class Foo { 'bar'(){} }",
       options: ['backtick'],
     },
     {
-      code: `class Foo { static ''(){} }`,
+      code: "class Foo { static ''(){} }",
       options: ['backtick'],
     },
 
@@ -505,30 +510,30 @@ abstract class Foo {
 
   invalid: [
     {
-      code: `var foo = 'bar';`,
-      output: `var foo = "bar";`,
+      code: "var foo = 'bar';",
+      output: 'var foo = "bar";',
       errors: [useDoubleQuote],
     },
     {
-      code: `var foo = "bar";`,
-      output: `var foo = 'bar';`,
+      code: 'var foo = "bar";',
+      output: "var foo = 'bar';",
       options: ['single'],
       errors: [useSingleQuote],
     },
     {
       code: 'var foo = `bar`;',
-      output: `var foo = 'bar';`,
+      output: "var foo = 'bar';",
       options: ['single'],
       errors: [useSingleQuote],
     },
     {
-      code: `var foo = 'don\\'t';`,
-      output: `var foo = "don't";`,
+      code: "var foo = 'don\\'t';",
+      output: 'var foo = "don\'t";',
       errors: [useDoubleQuote],
     },
     {
-      code: `var msg = "Plugin '" + name + "' not found"`,
-      output: `var msg = 'Plugin \\'' + name + '\\' not found'`,
+      code: 'var msg = "Plugin \'" + name + "\' not found"',
+      output: "var msg = 'Plugin \\'' + name + '\\' not found'",
       options: ['single'],
       errors: [
         { ...useSingleQuote, column: 11 },
@@ -536,20 +541,20 @@ abstract class Foo {
       ],
     },
     {
-      code: `var foo = 'bar';`,
-      output: `var foo = "bar";`,
+      code: "var foo = 'bar';",
+      output: 'var foo = "bar";',
       options: ['double'],
       errors: [useDoubleQuote],
     },
     {
       code: 'var foo = `bar`;',
-      output: `var foo = "bar";`,
+      output: 'var foo = "bar";',
       options: ['double'],
       errors: [useDoubleQuote],
     },
     {
-      code: `var foo = "bar";`,
-      output: `var foo = 'bar';`,
+      code: 'var foo = "bar";',
+      output: "var foo = 'bar';",
       options: [
         'single',
         {
@@ -559,8 +564,8 @@ abstract class Foo {
       errors: [useSingleQuote],
     },
     {
-      code: `var foo = 'bar';`,
-      output: `var foo = "bar";`,
+      code: "var foo = 'bar';",
+      output: 'var foo = "bar";',
       options: [
         'double',
         {
@@ -570,8 +575,8 @@ abstract class Foo {
       errors: [useDoubleQuote],
     },
     {
-      code: `var foo = '\\\\';`,
-      output: `var foo = "\\\\\";`, // eslint-disable-line no-useless-escape
+      code: "var foo = '\\\\';",
+      output: 'var foo = "\\\\";',
       options: [
         'double',
         {
@@ -581,8 +586,8 @@ abstract class Foo {
       errors: [useDoubleQuote],
     },
     {
-      code: `var foo = "bar";`,
-      output: `var foo = 'bar';`,
+      code: 'var foo = "bar";',
+      output: "var foo = 'bar';",
       options: [
         'single',
         {
@@ -592,8 +597,8 @@ abstract class Foo {
       errors: [useSingleQuote],
     },
     {
-      code: `var foo = 'bar';`,
-      output: `var foo = "bar";`,
+      code: "var foo = 'bar';",
+      output: 'var foo = "bar";',
       options: [
         'double',
         {
@@ -603,7 +608,7 @@ abstract class Foo {
       errors: [useDoubleQuote],
     },
     {
-      code: `var foo = 'bar';`,
+      code: "var foo = 'bar';",
       output: 'var foo = `bar`;',
       options: ['backtick'],
       errors: [useBacktick],
@@ -621,7 +626,7 @@ abstract class Foo {
       errors: [useBacktick],
     },
     {
-      code: `var foo = "bar";`,
+      code: 'var foo = "bar";',
       output: 'var foo = `bar`;',
       options: [
         'backtick',
@@ -632,7 +637,7 @@ abstract class Foo {
       errors: [useBacktick],
     },
     {
-      code: `var foo = 'bar';`,
+      code: "var foo = 'bar';",
       output: 'var foo = `bar`;',
       options: [
         'backtick',
@@ -665,14 +670,14 @@ abstract class Foo {
 
     // `backtick` should warn computed property names.
     {
-      code: `var obj = {["key0"]: 0, ['key1']: 1};`,
+      code: 'var obj = {["key0"]: 0, [\'key1\']: 1};',
       output: 'var obj = {[`key0`]: 0, [`key1`]: 1};',
       options: ['backtick'],
       parserOptions: { ecmaVersion: 6 },
       errors: [useBacktick, useBacktick],
     },
     {
-      code: `class Foo { ['a'](){} static ['b'](){} }`,
+      code: "class Foo { ['a'](){} static ['b'](){} }",
       output: 'class Foo { [`a`](){} static [`b`](){} }',
       options: ['backtick'],
       errors: [useBacktick, useBacktick],
@@ -680,8 +685,8 @@ abstract class Foo {
 
     // https://github.com/eslint/eslint/issues/7084
     {
-      code: `<div blah={"blah"} />`,
-      output: `<div blah={'blah'} />`,
+      code: '<div blah={"blah"} />',
+      output: "<div blah={'blah'} />",
       options: [`single`],
       parserOptions: {
         ecmaFeatures: {
@@ -691,8 +696,8 @@ abstract class Foo {
       errors: [useSingleQuote],
     },
     {
-      code: `<div blah={'blah'} />`,
-      output: `<div blah={"blah"} />`,
+      code: "<div blah={'blah'} />",
+      output: '<div blah={"blah"} />',
       options: ['double'],
       parserOptions: {
         ecmaFeatures: {
@@ -702,7 +707,7 @@ abstract class Foo {
       errors: [useDoubleQuote],
     },
     {
-      code: `<div blah={'blah'} />`,
+      code: "<div blah={'blah'} />",
       output: '<div blah={`blah`} />',
       options: ['backtick'],
       parserOptions: {
@@ -736,7 +741,7 @@ abstract class Foo {
     },
     {
       code: '() => { foo(); `use strict`; }',
-      output: `() => { foo(); "use strict"; }`,
+      output: '() => { foo(); "use strict"; }',
       errors: [useDoubleQuote],
     },
     {
diff --git a/packages/eslint-plugin/tests/rules/require-array-sort-compare.test.ts b/packages/eslint-plugin/tests/rules/require-array-sort-compare.test.ts
index d3a49c60f65..6362089d9c1 100644
--- a/packages/eslint-plugin/tests/rules/require-array-sort-compare.test.ts
+++ b/packages/eslint-plugin/tests/rules/require-array-sort-compare.test.ts
@@ -15,75 +15,81 @@ ruleTester.run('require-array-sort-compare', rule, {
   valid: [
     `
       function f(a: any[]) {
-        a.sort(undefined)
+        a.sort(undefined);
       }
     `,
     `
       function f(a: any[]) {
-        a.sort((a, b) => a - b)
+        a.sort((a, b) => a - b);
       }
     `,
     `
       function f(a: Array<string>) {
-        a.sort(undefined)
+        a.sort(undefined);
       }
     `,
     `
       function f(a: Array<number>) {
-        a.sort((a, b) => a - b)
+        a.sort((a, b) => a - b);
       }
     `,
     `
       function f(a: { sort(): void }) {
-        a.sort()
+        a.sort();
       }
     `,
     `
-      class A { sort(): void {} }
+      class A {
+        sort(): void {}
+      }
       function f(a: A) {
-        a.sort()
+        a.sort();
       }
     `,
     `
-      interface A { sort(): void }
+      interface A {
+        sort(): void;
+      }
       function f(a: A) {
-        a.sort()
+        a.sort();
       }
     `,
     `
-      interface A { sort(): void }
+      interface A {
+        sort(): void;
+      }
       function f<T extends A>(a: T) {
-        a.sort()
+        a.sort();
       }
     `,
     `
       function f(a: any) {
-        a.sort()
+        a.sort();
       }
     `,
     `
       namespace UserDefined {
         interface Array {
-          sort(): void
+          sort(): void;
         }
         function f(a: Array) {
-          a.sort()
+          a.sort();
         }
       }
     `,
     // optional chain
     `
       function f(a: any[]) {
-        a?.sort((a, b) => a - b)
+        a?.sort((a, b) => a - b);
       }
     `,
     `
       namespace UserDefined {
         interface Array {
-          sort(): void
+          sort(): void;
         }
         function f(a: Array) {
-          a?.sort()
+          a?.sort();
         }
       }
     `,
@@ -92,7 +98,7 @@ ruleTester.run('require-array-sort-compare', rule, {
     {
       code: `
         function f(a: Array<any>) {
-          a.sort()
+          a.sort();
         }
       `,
       errors: [{ messageId: 'requireCompare' }],
@@ -100,7 +106,7 @@ ruleTester.run('require-array-sort-compare', rule, {
     {
       code: `
         function f(a: string[]) {
-          a.sort()
+          a.sort();
         }
       `,
       errors: [{ messageId: 'requireCompare' }],
@@ -108,8 +114,7 @@ ruleTester.run('require-array-sort-compare', rule, {
     {
       code: `
         function f(a: string | string[]) {
-          if (Array.isArray(a))
-            a.sort()
+          if (Array.isArray(a)) a.sort();
         }
       `,
       errors: [{ messageId: 'requireCompare' }],
@@ -117,7 +122,7 @@ ruleTester.run('require-array-sort-compare', rule, {
     {
       code: `
         function f(a: number[] | string[]) {
-          a.sort()
+          a.sort();
         }
       `,
       errors: [{ messageId: 'requireCompare' }],
@@ -125,7 +130,7 @@ ruleTester.run('require-array-sort-compare', rule, {
     {
       code: `
         function f<T extends number[]>(a: T) {
-          a.sort()
+          a.sort();
         }
       `,
       errors: [{ messageId: 'requireCompare' }],
@@ -133,7 +138,7 @@ ruleTester.run('require-array-sort-compare', rule, {
     {
       code: `
         function f<T, U extends T[]>(a: U) {
-          a.sort()
+          a.sort();
         }
       `,
       errors: [{ messageId: 'requireCompare' }],
@@ -142,7 +147,7 @@ ruleTester.run('require-array-sort-compare', rule, {
     {
       code: `
         function f(a: string[]) {
-          a?.sort()
+          a?.sort();
         }
       `,
       errors: [{ messageId: 'requireCompare' }],
diff --git a/packages/eslint-plugin/tests/rules/require-await.test.ts b/packages/eslint-plugin/tests/rules/require-await.test.ts
index caea93fbfb9..05c4bf739b9 100644
--- a/packages/eslint-plugin/tests/rules/require-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/require-await.test.ts
@@ -15,131 +15,168 @@ const ruleTester = new RuleTester({
 ruleTester.run('require-await', rule, {
   valid: [
     // Non-async function declaration
-    `function numberOne(): number {
-          return 1;
-        }`,
+    `
+function numberOne(): number {
+  return 1;
+}
+    `,
     // Non-async function expression
-    `const numberOne = function(): number {
-          return 1;
-        }`,
+    `
+const numberOne = function(): number {
+  return 1;
+};
+    `,
     // Non-async arrow function expression (concise-body)
-    `const numberOne = (): number => 1;`,
+    `
+      const numberOne = (): number => 1;
+    `,
     // Non-async arrow function expression (block-body)
-    `const numberOne = (): number => {
-          return 1;
-        };`,
+    `
+const numberOne = (): number => {
+  return 1;
+};
+    `,
     // Non-async function that returns a promise
     // https://github.com/typescript-eslint/typescript-eslint/issues/1226
     `
-    function delay() {
-      return Promise.resolve();
-    }
-        `,
+function delay() {
+  return Promise.resolve();
+}
+    `,
     `
-    const delay = () => {
-      return Promise.resolve();
-    }
-        `,
-    `const delay = () => Promise.resolve();`,
+const delay = () => {
+  return Promise.resolve();
+};
+    `,
+    'const delay = () => Promise.resolve();',
     // Async function declaration with await
-    `async function numberOne(): Promise<number> {
-          return await 1;
-        }`,
+    `
+async function numberOne(): Promise<number> {
+  return await 1;
+}
+    `,
     // Async function expression with await
-    `const numberOne = async function(): Promise<number> {
-          return await 1;
-        }`,
+    `
+const numberOne = async function(): Promise<number> {
+  return await 1;
+};
+    `,
     // Async arrow function expression with await (concise-body)
-    `const numberOne = async (): Promise<number> => await 1;`,
+    'const numberOne = async (): Promise<number> => await 1;',
     // Async arrow function expression with await (block-body)
-    `const numberOne = async (): Promise<number> => {
-          return await 1;
-        };`,
+    `
+const numberOne = async (): Promise<number> => {
+  return await 1;
+};
+    `,
     // Async function declaration with promise return
-    `async function numberOne(): Promise<number> {
-          return Promise.resolve(1);
-        }`,
+    `
+async function numberOne(): Promise<number> {
+  return Promise.resolve(1);
+}
+    `,
     // Async function expression with promise return
-    `const numberOne = async function(): Promise<number> {
-          return Promise.resolve(1);
-        }`,
+    `
+const numberOne = async function(): Promise<number> {
+  return Promise.resolve(1);
+};
+    `,
     // Async arrow function with promise return (concise-body)
-    `const numberOne = async (): Promise<number> => Promise.resolve(1);`,
+    'const numberOne = async (): Promise<number> => Promise.resolve(1);',
     // Async arrow function with promise return (block-body)
-    `const numberOne = async (): Promise<number> => {
-          return Promise.resolve(1);
-        };`,
+    `
+const numberOne = async (): Promise<number> => {
+  return Promise.resolve(1);
+};
+    `,
     // Async function declaration with async function return
-    `async function numberOne(): Promise<number> {
-          return getAsyncNumber(1);
-        }
-        async function getAsyncNumber(x: number): Promise<number> {
-          return Promise.resolve(x);
-        }`,
+    `
+async function numberOne(): Promise<number> {
+  return getAsyncNumber(1);
+}
+async function getAsyncNumber(x: number): Promise<number> {
+  return Promise.resolve(x);
+}
+    `,
     // Async function expression with async function return
-    `const numberOne = async function(): Promise<number> {
-          return getAsyncNumber(1);
-        }
-        const getAsyncNumber = async function(x: number): Promise<number> {
-          return Promise.resolve(x);
-        }`,
+    `
+const numberOne = async function(): Promise<number> {
+  return getAsyncNumber(1);
+};
+const getAsyncNumber = async function(x: number): Promise<number> {
+  return Promise.resolve(x);
+};
+    `,
     // Async arrow function with async function return (concise-body)
-    `const numberOne = async (): Promise<number> => getAsyncNumber(1);
-        const getAsyncNumber = async function(x: number): Promise<number> {
-          return Promise.resolve(x);
-        }`,
+    `
+const numberOne = async (): Promise<number> => getAsyncNumber(1);
+const getAsyncNumber = async function(x: number): Promise<number> {
+  return Promise.resolve(x);
+};
+    `,
     // Async arrow function with async function return (block-body)
-    `const numberOne = async (): Promise<number> => {
-          return getAsyncNumber(1);
-        };
-        const getAsyncNumber = async function(x: number): Promise<number> {
-          return Promise.resolve(x);
-        }`,
+    `
+const numberOne = async (): Promise<number> => {
+  return getAsyncNumber(1);
+};
+const getAsyncNumber = async function(x: number): Promise<number> {
+  return Promise.resolve(x);
+};
+    `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/1188
     `
-    async function testFunction(): Promise<void> {
-      await Promise.all([1, 2, 3].map(
-        // this should not trigger an error on the parent function
-        async value => Promise.resolve(value)
-      ))
-    }
-        `,
+async function testFunction(): Promise<void> {
+  await Promise.all(
+    [1, 2, 3].map(
+      // this should not trigger an error on the parent function
+      async value => Promise.resolve(value),
+    ),
+  );
+}
+    `,
+    'async function* run() {}',
     `
-        async function* run() {
-          await new Promise(resolve => setTimeout(resolve, 100));
-          yield 'Hello';
-          console.log('World');
-        }
-        `,
-    'async function* run() { }',
-    'async function* asyncGenerator() { await Promise.resolve(); yield 1 }',
-    'function* test6() { yield* syncGenerator() }',
-    'function* test8() { yield syncGenerator() }',
-    'function* syncGenerator() { yield 1 }',
+async function* run() {
+  await new Promise(resolve => setTimeout(resolve, 100));
+  yield 'Hello';
+  console.log('World');
+}
+    `,
     `
-    async function* asyncGenerator() {
-      await Promise.resolve()
-      yield 1
-    }
-    async function* test1() {yield* asyncGenerator() }
+function* test6() {
+  yield* syncGenerator();
+}
+    `,
+    `
+function* syncGenerator() {
+  yield 1;
+}
+    `,
+    `
+async function* asyncGenerator() {
+  await Promise.resolve();
+  yield 1;
+}
+async function* test1() {
+  yield* asyncGenerator();
+}
+    `,
+    'const foo: () => void = async function*() {};',
+    `
+async function* foo(): Promise<string> {
+  return new Promise(res => res(\`hello\`));
+}
     `,
-    `async function* foo() {
-            await Promise.resolve()
-            yield 1
-          }
-          async function* bar() {
-            yield* foo()
-          }`,
-    'const foo : () => void = async function *(){}',
-    'async function* foo() : Promise<string> { return new Promise((res) => res(`hello`)) }',
   ],
 
   invalid: [
     {
       // Async function declaration with no await
-      code: `async function numberOne(): Promise<number> {
-            return 1;
-          }`,
+      code: `
+async function numberOne(): Promise<number> {
+  return 1;
+}
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -151,9 +188,11 @@ ruleTester.run('require-await', rule, {
     },
     {
       // Async function expression with no await
-      code: `const numberOne = async function(): Promise<number> {
-            return 1;
-          }`,
+      code: `
+const numberOne = async function(): Promise<number> {
+  return 1;
+};
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -165,7 +204,7 @@ ruleTester.run('require-await', rule, {
     },
     {
       // Async arrow function expression with no await
-      code: `const numberOne = async (): Promise<number> => 1;`,
+      code: 'const numberOne = async (): Promise<number> => 1;',
       errors: [
         {
           messageId: 'missingAwait',
@@ -177,8 +216,13 @@ ruleTester.run('require-await', rule, {
     },
     {
       // non-async function with await inside async function without await
-      code:
-        'async function foo() { function nested() { await doSomething() } }',
+      code: `
+        async function foo() {
+          function nested() {
+            await doSomething();
+          }
+        }
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -189,7 +233,11 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async function* foo() : void { doSomething() }',
+      code: `
+async function* foo(): void {
+  doSomething();
+}
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -200,7 +248,11 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async function* foo() { yield 1 }',
+      code: `
+async function* foo() {
+  yield 1;
+}
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -211,18 +263,11 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async function* run() { console.log("bar") }',
-      errors: [
-        {
-          messageId: 'missingAwait',
-          data: {
-            name: "Async generator function 'run'",
-          },
-        },
-      ],
-    },
-    {
-      code: 'const foo = async function *(){ console.log("bar") }',
+      code: `
+const foo = async function*() {
+  console.log('bar');
+};
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -233,34 +278,34 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async function* syncGenerator() { yield 1 }',
-      errors: [
-        {
-          messageId: 'missingAwait',
-          data: {
-            name: "Async generator function 'syncGenerator'",
-          },
-        },
-      ],
-    },
-    {
-      code: 'async function* test3() { yield asyncGenerator() }',
+      code: `
+async function* asyncGenerator() {
+  yield 1;
+}
+      `,
       errors: [
         {
           messageId: 'missingAwait',
           data: {
-            name: "Async generator function 'test3'",
+            name: "Async generator function 'asyncGenerator'",
           },
         },
       ],
     },
     {
-      code: 'async function* test7() { yield syncGenerator() }',
+      code: `
+function* syncGenerator() {
+  yield 1;
+}
+async function* asyncGenerator() {
+  yield* syncGenerator();
+}
+      `,
       errors: [
         {
           messageId: 'missingAwait',
           data: {
-            name: "Async generator function 'test7'",
+            name: "Async generator function 'asyncGenerator'",
           },
         },
       ],
@@ -271,36 +316,84 @@ ruleTester.run('require-await', rule, {
 // https://github.com/eslint/eslint/blob/03a69dbe86d5b5768a310105416ae726822e3c1c/tests/lib/rules/require-await.js#L25-L132
 ruleTester.run('require-await', rule, {
   valid: [
-    'async function foo() { await doSomething() }',
-    '(async function() { await doSomething() })',
-    'async () => { await doSomething() }',
-    'async () => await doSomething()',
-    '({ async foo() { await doSomething() } })',
-    'class A { async foo() { await doSomething() } }',
-    '(class { async foo() { await doSomething() } })',
-    'async function foo() { await (async () => { await doSomething() }) }',
+    `
+async function foo() {
+  await doSomething();
+}
+    `,
+    `
+(async function() {
+  await doSomething();
+});
+    `,
+    `
+async () => {
+  await doSomething();
+};
+    `,
+    'async () => await doSomething();',
+    `
+({
+  async foo() {
+    await doSomething();
+  },
+});
+    `,
+    `
+class A {
+  async foo() {
+    await doSomething();
+  }
+}
+    `,
+    `
+(class {
+  async foo() {
+    await doSomething();
+  }
+});
+    `,
+    `
+async function foo() {
+  await (async () => {
+    await doSomething();
+  });
+}
+    `,
     // empty functions are ok.
     'async function foo() {}',
-    'async () => {}',
+    'async () => {};',
     // normal functions are ok.
-    'function foo() { doSomething() }',
+    `
+function foo() {
+  doSomething();
+}
+    `,
     // for-await-of
-    'async function foo() { for await (x of xs); }',
+    `
+async function foo() {
+  for await (x of xs);
+}
+    `,
     // global await
     {
-      code: 'await foo()',
+      code: 'await foo();',
     },
     {
       code: `
-            for await (let num of asyncIterable) {
-                console.log(num);
-            }
-          `,
+for await (let num of asyncIterable) {
+  console.log(num);
+}
+      `,
     },
   ],
   invalid: [
     {
-      code: 'async function foo() { doSomething() }',
+      code: `
+        async function foo() {
+          doSomething();
+        }
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -309,7 +402,11 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: '(async function() { doSomething() })',
+      code: `
+        (async function() {
+          doSomething();
+        });
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -318,7 +415,11 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async () => { doSomething() }',
+      code: `
+        async () => {
+          doSomething();
+        };
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -327,7 +428,7 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async () => doSomething()',
+      code: 'async () => doSomething();',
       errors: [
         {
           messageId: 'missingAwait',
@@ -336,7 +437,13 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: '({ async foo() { doSomething() } })',
+      code: `
+        ({
+          async foo() {
+            doSomething();
+          },
+        });
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -345,7 +452,13 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'class A { async foo() { doSomething() } }',
+      code: `
+        class A {
+          async foo() {
+            doSomething();
+          }
+        }
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -354,7 +467,13 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: '(class { async foo() { doSomething() } })',
+      code: `
+        (class {
+          async foo() {
+            doSomething();
+          }
+        });
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -363,7 +482,13 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: "(class { async ''() { doSomething() } })",
+      code: `
+        (class {
+          async ''() {
+            doSomething();
+          }
+        });
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -372,7 +497,13 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async function foo() { async () => { await doSomething() } }',
+      code: `
+        async function foo() {
+          async () => {
+            await doSomething();
+          };
+        }
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -381,7 +512,13 @@ ruleTester.run('require-await', rule, {
       ],
     },
     {
-      code: 'async function foo() { await (async () => { doSomething() }) }',
+      code: `
+        async function foo() {
+          await (async () => {
+            doSomething();
+          });
+        }
+      `,
       errors: [
         {
           messageId: 'missingAwait',
@@ -389,23 +526,5 @@ ruleTester.run('require-await', rule, {
         },
       ],
     },
-    {
-      code: 'async function* run() { yield * anotherAsyncGenerator() }',
-      errors: [
-        {
-          messageId: 'missingAwait',
-          data: { name: "Async generator function 'run'" },
-        },
-      ],
-    },
-    {
-      code: 'async function* run() { yield* 1 }',
-      errors: [
-        {
-          messageId: 'missingAwait',
-          data: { name: "Async generator function 'run'" },
-        },
-      ],
-    },
   ],
 });
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 6270b61eec3..43682806f59 100644
--- a/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-plus-operands.test.ts
@@ -13,20 +13,25 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('restrict-plus-operands', rule, {
   valid: [
-    `var x = 5;`,
-    `var y = "10";`,
-    `var z = 8.2;`,
-    `var w = "6.5";`,
-    `var foo = 5 + 10;`,
-    `var foo = "5.5" + "10";`,
-    `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`,
+    'var x = 5;',
+    "var y = '10';",
+    'var z = 8.2;',
+    "var w = '6.5';",
+    'var foo = 5 + 10;',
+    "var foo = '5.5' + '10';",
+    "var foo = parseInt('5.5', 10) + 10;",
+    "var foo = parseFloat('5.5', 10) + 10;",
+    'var foo = 1n + 1n;',
+    'var foo = BigInt(1) + 1n;',
     `
-function test(s: string, n: number) : number { return 2; }
-var foo = test("5.5", 10) + 10;
+      var foo = 1n;
+      foo + 2n;
+    `,
+    `
+function test(s: string, n: number): number {
+  return 2;
+}
+var foo = test('5.5', 10) + 10;
     `,
     `
 var x = 5;
@@ -34,57 +39,63 @@ var z = 8.2;
 var foo = x + z;
     `,
     `
-var w = "6.5";
-var y = "10";
+var w = '6.5';
+var y = '10';
 var foo = y + w;
     `,
     'var foo = 1 + 1;',
     "var foo = '1' + '1';",
     `
-var pair: { first: number, second: string } = { first: 5, second: "10" };
+var pair: { first: number; second: string } = { first: 5, second: '10' };
 var foo = pair.first + 10;
     `,
     `
-var pair: { first: number, second: string } = { first: 5, second: "10" };
+var pair: { first: number; second: string } = { first: 5, second: '10' };
 var foo = pair.first + (10 as number);
     `,
     `
-var pair: { first: number, second: string } = { first: 5, second: "10" };
-var foo = "5.5" + pair.second;
+var pair: { first: number; second: string } = { first: 5, second: '10' };
+var foo = '5.5' + pair.second;
+    `,
+    `
+var pair: { first: number; second: string } = { first: 5, second: '10' };
+var foo = ('5.5' as string) + pair.second;
     `,
     `
-var pair: { first: number, second: string } = { first: 5, second: "10" };
-var foo = ("5.5" as string) + pair.second;
+      const foo =
+        'hello' +
+        (someBoolean ? 'a' : 'b') +
+        (() => (someBoolean ? 'c' : 'd'))() +
+        'e';
     `,
-    `const foo = 'hello' + (someBoolean ? 'a' : 'b') + (() => someBoolean ? 'c' : 'd')() + 'e';`,
-    `const balls = true;`,
-    `balls === true;`,
+    'const balls = true;',
+    'balls === true;',
     // https://github.com/typescript-eslint/typescript-eslint/issues/230
     `
 function foo<T extends string>(a: T) {
-    return a + "";
+  return a + '';
 }
     `,
     `
-function foo<T extends "a" | "b">(a: T) {
-    return a + "";
+function foo<T extends 'a' | 'b'>(a: T) {
+  return a + '';
 }
     `,
     `
 function foo<T extends number>(a: T) {
-    return a + 1;
+  return a + 1;
 }
     `,
     `
 function foo<T extends 1>(a: T) {
-    return a + 1;
+  return a + 1;
 }
     `,
     {
       code: `
 let foo: number = 0;
 foo += 1;
-    `,
+      `,
       options: [
         {
           checkCompoundAssignments: false,
@@ -94,8 +105,8 @@ foo += 1;
     {
       code: `
 let foo: number = 0;
-foo += "string";
-    `,
+foo += 'string';
+      `,
       options: [
         {
           checkCompoundAssignments: false,
@@ -125,7 +136,7 @@ foo += "string";
       ],
     },
     {
-      code: `var foo = 5 + "10";`,
+      code: "var foo = 5 + '10';",
       errors: [
         {
           messageId: 'notStrings',
@@ -135,7 +146,7 @@ foo += "string";
       ],
     },
     {
-      code: `var foo = [] + 5;`,
+      code: 'var foo = [] + 5;',
       errors: [
         {
           messageId: 'notNumbers',
@@ -145,7 +156,7 @@ foo += "string";
       ],
     },
     {
-      code: `var foo = [] + {};`,
+      code: 'var foo = [] + [];',
       errors: [
         {
           messageId: 'notNumbers',
@@ -155,7 +166,7 @@ foo += "string";
       ],
     },
     {
-      code: `var foo = [] + [];`,
+      code: 'var foo = 5 + [];',
       errors: [
         {
           messageId: 'notNumbers',
@@ -165,17 +176,7 @@ foo += "string";
       ],
     },
     {
-      code: `var foo = 5 + [];`,
-      errors: [
-        {
-          messageId: 'notNumbers',
-          line: 1,
-          column: 11,
-        },
-      ],
-    },
-    {
-      code: `var foo = "5" + {};`,
+      code: "var foo = '5' + {};",
       errors: [
         {
           messageId: 'notStrings',
@@ -185,7 +186,7 @@ foo += "string";
       ],
     },
     {
-      code: `var foo = 5.5 + "5";`,
+      code: "var foo = 5.5 + '5';",
       errors: [
         {
           messageId: 'notStrings',
@@ -195,7 +196,7 @@ foo += "string";
       ],
     },
     {
-      code: `var foo = "5.5" + 5;`,
+      code: "var foo = '5.5' + 5;",
       errors: [
         {
           messageId: 'notStrings',
@@ -207,9 +208,9 @@ foo += "string";
     {
       code: `
 var x = 5;
-var y = "10";
+var y = '10';
 var foo = x + y;
-            `,
+      `,
       errors: [
         {
           messageId: 'notStrings',
@@ -221,9 +222,9 @@ var foo = x + y;
     {
       code: `
 var x = 5;
-var y = "10";
+var y = '10';
 var foo = y + x;
-            `,
+      `,
       errors: [
         {
           messageId: 'notStrings',
@@ -236,7 +237,7 @@ var foo = y + x;
       code: `
 var x = 5;
 var foo = x + {};
-            `,
+      `,
       errors: [
         {
           messageId: 'notNumbers',
@@ -247,9 +248,9 @@ var foo = x + {};
     },
     {
       code: `
-var y = "10";
+var y = '10';
 var foo = [] + y;
-            `,
+      `,
       errors: [
         {
           messageId: 'notStrings',
@@ -260,9 +261,9 @@ var foo = [] + y;
     },
     {
       code: `
-var pair: { first: number, second: string } = { first: 5, second: "10" };
-var foo = pair.first + "10";
-            `,
+var pair: { first: number; second: string } = { first: 5, second: '10' };
+var foo = pair.first + '10';
+      `,
       errors: [
         {
           messageId: 'notStrings',
@@ -273,9 +274,9 @@ var foo = pair.first + "10";
     },
     {
       code: `
-var pair: { first: number, second: string } = { first: 5, second: "10" };
+var pair: { first: number; second: string } = { first: 5, second: '10' };
 var foo = 5 + pair.second;
-            `,
+      `,
       errors: [
         {
           messageId: 'notStrings',
@@ -285,7 +286,7 @@ var foo = 5 + pair.second;
       ],
     },
     {
-      code: `var foo = parseInt("5.5", 10) + "10";`,
+      code: "var foo = parseInt('5.5', 10) + '10';",
       errors: [
         {
           messageId: 'notStrings',
@@ -296,9 +297,9 @@ var foo = 5 + pair.second;
     },
     {
       code: `
-var pair = { first: 5, second: "10" };
+var pair = { first: 5, second: '10' };
 var foo = pair + pair;
-            `,
+      `,
       errors: [
         {
           messageId: 'notNumbers',
@@ -308,7 +309,7 @@ var foo = pair + pair;
       ],
     },
     {
-      code: `var foo = 1n + 1`,
+      code: 'var foo = 1n + 1;',
       errors: [
         {
           messageId: 'notBigInts',
@@ -318,7 +319,7 @@ var foo = pair + pair;
       ],
     },
     {
-      code: `var foo = 1 + 1n`,
+      code: 'var foo = 1 + 1n;',
       errors: [
         {
           messageId: 'notBigInts',
@@ -328,22 +329,28 @@ var foo = pair + pair;
       ],
     },
     {
-      code: `var foo = 1n; foo + 1`,
+      code: `
+        var foo = 1n;
+        foo + 1;
+      `,
       errors: [
         {
           messageId: 'notBigInts',
-          line: 1,
-          column: 15,
+          line: 3,
+          column: 9,
         },
       ],
     },
     {
-      code: `var foo = 1; foo + 1n`,
+      code: `
+        var foo = 1;
+        foo + 1n;
+      `,
       errors: [
         {
           messageId: 'notBigInts',
-          line: 1,
-          column: 14,
+          line: 3,
+          column: 9,
         },
       ],
     },
@@ -351,63 +358,63 @@ var foo = pair + pair;
     {
       code: `
 function foo<T extends string>(a: T) {
-    return a + 1;
+  return a + 1;
 }
       `,
       errors: [
         {
           messageId: 'notStrings',
           line: 3,
-          column: 12,
+          column: 10,
         },
       ],
     },
     {
       code: `
-function foo<T extends "a" | "b">(a: T) {
-    return a + 1;
+function foo<T extends 'a' | 'b'>(a: T) {
+  return a + 1;
 }
       `,
       errors: [
         {
           messageId: 'notStrings',
           line: 3,
-          column: 12,
+          column: 10,
         },
       ],
     },
     {
       code: `
 function foo<T extends number>(a: T) {
-    return a + "";
+  return a + '';
 }
       `,
       errors: [
         {
           messageId: 'notStrings',
           line: 3,
-          column: 12,
+          column: 10,
         },
       ],
     },
     {
       code: `
 function foo<T extends 1>(a: T) {
-    return a + "";
+  return a + '';
 }
       `,
       errors: [
         {
           messageId: 'notStrings',
           line: 3,
-          column: 12,
+          column: 10,
         },
       ],
     },
     {
       code: `
 let foo: string | undefined;
-foo += "some data";
+foo += 'some data';
       `,
       options: [
         {
diff --git a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
index cdf59b0c819..3e18e7ac1b1 100644
--- a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
@@ -15,15 +15,15 @@ ruleTester.run('restrict-template-expressions', rule, {
   valid: [
     // Base case
     `
-      const msg = \`arg = \${"foo"}\`;
+      const msg = \`arg = \${'foo'}\`;
     `,
     `
-      const arg = "foo";
+      const arg = 'foo';
       const msg = \`arg = \${arg}\`;
     `,
     `
-      const arg = "foo";
-      const msg = \`arg = \${arg || "default"}\`;
+      const arg = 'foo';
+      const msg = \`arg = \${arg || 'default'}\`;
     `,
     `
       function test<T extends string>(arg: T) {
@@ -50,14 +50,14 @@ ruleTester.run('restrict-template-expressions', rule, {
       options: [{ allowNumber: true }],
       code: `
         const arg = 123;
-        const msg = \`arg = \${arg || "default"}\`;
+        const msg = \`arg = \${arg || 'default'}\`;
       `,
     },
     {
       options: [{ allowNumber: true }],
       code: `
         const arg = 123n;
-        const msg = \`arg = \${arg || "default"}\`;
+        const msg = \`arg = \${arg || 'default'}\`;
       `,
     },
     {
@@ -96,7 +96,7 @@ ruleTester.run('restrict-template-expressions', rule, {
       options: [{ allowBoolean: true }],
       code: `
         const arg = true;
-        const msg = \`arg = \${arg || "default"}\`;
+        const msg = \`arg = \${arg || 'default'}\`;
       `,
     },
     {
@@ -150,7 +150,7 @@ ruleTester.run('restrict-template-expressions', rule, {
     {
       options: [{ allowNumber: true, allowBoolean: true, allowNullable: true }],
       code: `
-        type All = string | number | boolean | null | undefined
+        type All = string | number | boolean | null | undefined;
         function test<T extends All>(arg: T) {
           return \`arg = \${arg}\`;
         }
diff --git a/packages/eslint-plugin/tests/rules/return-await.test.ts b/packages/eslint-plugin/tests/rules/return-await.test.ts
index 8599a937e19..94c2c398733 100644
--- a/packages/eslint-plugin/tests/rules/return-await.test.ts
+++ b/packages/eslint-plugin/tests/rules/return-await.test.ts
@@ -15,201 +15,246 @@ const ruleTester = new RuleTester({
 // default rule is in-try-catch
 ruleTester.run('return-await', rule, {
   valid: [
-    `function test() {
-      return;
-    }`,
-    `function test() {
-      return 1;
-    }`,
-    `async function test() {
-      return;
-    }`,
-    `async function test() {
-      return 1;
-    }`,
-    `const test = () => 1;`,
-    `const test = async () => 1;`,
-    `async function test() {
-      return Promise.resolve(1);
-    }`,
-    `async function test() {
-      try {
-        return await Promise.resolve(1);
-      } catch (e) {
-        return await Promise.resolve(2);
-      } finally {
-        console.log('cleanup');
+    `
+      function test() {
+        return;
       }
-    }`,
-    `async function test() {
-      try {
-        const one = await Promise.resolve(1);
-        return one;
-      } catch (e) {
-        const two = await Promise.resolve(2);
-        return two;
-      } finally {
-        console.log('cleanup');
+    `,
+    `
+      function test() {
+        return 1;
+      }
+    `,
+    `
+      async function test() {
+        return;
+      }
+    `,
+    `
+      async function test() {
+        return 1;
+      }
+    `,
+    'const test = () => 1;',
+    'const test = async () => 1;',
+    `
+      async function test() {
+        return Promise.resolve(1);
+      }
+    `,
+    `
+      async function test() {
+        try {
+          return await Promise.resolve(1);
+        } catch (e) {
+          return await Promise.resolve(2);
+        } finally {
+          console.log('cleanup');
+        }
+      }
+    `,
+    `
+      async function test() {
+        try {
+          const one = await Promise.resolve(1);
+          return one;
+        } catch (e) {
+          const two = await Promise.resolve(2);
+          return two;
+        } finally {
+          console.log('cleanup');
+        }
       }
-    }`,
+    `,
     {
       options: ['in-try-catch'],
-      code: `function test() {
-        return 1;
-      }`,
+      code: `
+        function test() {
+          return 1;
+        }
+      `,
     },
     {
       options: ['in-try-catch'],
-      code: `async function test() {
-        return 1;
-      }`,
+      code: `
+        async function test() {
+          return 1;
+        }
+      `,
     },
     {
       options: ['in-try-catch'],
-      code: `const test = () => 1;`,
+      code: 'const test = () => 1;',
     },
     {
       options: ['in-try-catch'],
-      code: `const test = async () => 1;`,
+      code: 'const test = async () => 1;',
     },
     {
       options: ['in-try-catch'],
-      code: `async function test() {
-        return Promise.resolve(1);
-      }`,
+      code: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
     },
     {
       options: ['in-try-catch'],
-      code: `async function test() {
-      try {
-        return await Promise.resolve(1);
-      } catch (e) {
-        return await Promise.resolve(2);
-      } finally {
-        console.log('cleanup');
-      }
-    }`,
+      code: `
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
+        }
+      `,
     },
     {
       options: ['in-try-catch'],
-      code: `async function test() {
-      try {
-        const one = await Promise.resolve(1);
-        return one;
-      } catch (e) {
-        const two = await Promise.resolve(2);
-        return two;
-      } finally {
-        console.log('cleanup');
-      }
-    }`,
+      code: `
+        async function test() {
+          try {
+            const one = await Promise.resolve(1);
+            return one;
+          } catch (e) {
+            const two = await Promise.resolve(2);
+            return two;
+          } finally {
+            console.log('cleanup');
+          }
+        }
+      `,
     },
     {
       options: ['never'],
-      code: `async function test() {
-        return Promise.resolve(1);
-      }`,
+      code: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
     },
     {
       options: ['never'],
-      code: `const test = async () => Promise.resolve(1);`,
+      code: 'const test = async () => Promise.resolve(1);',
     },
     {
       options: ['never'],
-      code: `async function test() {
-        try {
-          return Promise.resolve(1);
-        } catch (e) {
-          return Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      code: `
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
+      `,
     },
     {
       options: ['always'],
-      code: `async function test() {
-        return await Promise.resolve(1);
-      }`,
+      code: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
     },
     {
       options: ['always'],
-      code: `const test = async () => await Promise.resolve(1);`,
+      code: 'const test = async () => await Promise.resolve(1);',
     },
     {
       options: ['always'],
-      code: `async function test() {
-        try {
-          return await Promise.resolve(1);
-        } catch (e) {
-          return await Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      code: `
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
+      `,
     },
     {
-      code: `async function test(): Promise<string> {
-        const res = await Promise.resolve('{}');
-        try {
-          return JSON.parse(res);
-        } catch (error) {
-          return res;
+      code: `
+        async function test(): Promise<string> {
+          const res = await Promise.resolve('{}');
+          try {
+            return JSON.parse(res);
+          } catch (error) {
+            return res;
+          }
         }
-      }`,
+      `,
     },
   ],
   invalid: [
     {
-      code: `async function test() {
-        return await 1;
-      }`,
-      output: `async function test() {
-        return 1;
-      }`,
+      code: `
+        async function test() {
+          return await 1;
+        }
+      `,
+      output: `
+        async function test() {
+          return 1;
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'nonPromiseAwait',
         },
       ],
     },
     {
-      code: `async function test() {
-        const foo = 1;
-        return await{foo};
-      }`,
-      output: `async function test() {
-        const foo = 1;
-        return {foo};
-      }`,
+      code: `
+        async function test() {
+          const foo = 1;
+          return await { foo };
+        }
+      `,
+      output: `
+        async function test() {
+          const foo = 1;
+          return { foo };
+        }
+      `,
       errors: [
         {
-          line: 3,
+          line: 4,
           messageId: 'nonPromiseAwait',
         },
       ],
     },
     {
-      code: `async function test() {
-        const foo = 1;
-        return await
-          foo;
-      }`,
-      output: `async function test() {
-        const foo = 1;
-        return foo;
-      }`,
+      code: `
+        async function test() {
+          const foo = 1;
+          return await foo;
+        }
+      `,
+      output: `
+        async function test() {
+          const foo = 1;
+          return foo;
+        }
+      `,
       errors: [
         {
-          line: 3,
+          line: 4,
           messageId: 'nonPromiseAwait',
         },
       ],
     },
     {
-      code: `const test = async () => await 1;`,
-      output: `const test = async () => 1;`,
+      code: 'const test = async () => await 1;',
+      output: 'const test = async () => 1;',
       errors: [
         {
           line: 1,
@@ -218,8 +263,8 @@ ruleTester.run('return-await', rule, {
       ],
     },
     {
-      code: `const test = async () => await/* comment */1;`,
-      output: `const test = async () => /* comment */1;`,
+      code: 'const test = async () => await /* comment */ 1;',
+      output: 'const test = async () => /* comment */ 1;',
       errors: [
         {
           line: 1,
@@ -228,8 +273,8 @@ ruleTester.run('return-await', rule, {
       ],
     },
     {
-      code: `const test = async () => await Promise.resolve(1);`,
-      output: `const test = async () => Promise.resolve(1);`,
+      code: 'const test = async () => await Promise.resolve(1);',
+      output: 'const test = async () => Promise.resolve(1);',
       errors: [
         {
           line: 1,
@@ -238,68 +283,80 @@ ruleTester.run('return-await', rule, {
       ],
     },
     {
-      code: `async function test() {
-        try {
-          return Promise.resolve(1);
-        } catch (e) {
-          return Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      code: `
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
-      output: `async function test() {
-        try {
-          return await Promise.resolve(1);
-        } catch (e) {
-          return await Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      `,
+      output: `
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
+      `,
       errors: [
         {
-          line: 3,
+          line: 4,
           messageId: 'requiredPromiseAwait',
         },
         {
-          line: 5,
+          line: 6,
           messageId: 'requiredPromiseAwait',
         },
       ],
     },
     {
-      code: `async function test() {
-        return await Promise.resolve(1);
-      }`,
-      output: `async function test() {
-        return Promise.resolve(1);
-      }`,
+      code: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
+      output: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'disallowedPromiseAwait',
         },
       ],
     },
     {
       options: ['in-try-catch'],
-      code: `async function test() {
-        return await 1;
-      }`,
-      output: `async function test() {
-        return 1;
-      }`,
+      code: `
+        async function test() {
+          return await 1;
+        }
+      `,
+      output: `
+        async function test() {
+          return 1;
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'nonPromiseAwait',
         },
       ],
     },
     {
       options: ['in-try-catch'],
-      code: `const test = async () => await 1;`,
-      output: `const test = async () => 1;`,
+      code: 'const test = async () => await 1;',
+      output: 'const test = async () => 1;',
       errors: [
         {
           line: 1,
@@ -309,8 +366,8 @@ ruleTester.run('return-await', rule, {
     },
     {
       options: ['in-try-catch'],
-      code: `const test = async () => await Promise.resolve(1);`,
-      output: `const test = async () => Promise.resolve(1);`,
+      code: 'const test = async () => await Promise.resolve(1);',
+      output: 'const test = async () => Promise.resolve(1);',
       errors: [
         {
           line: 1,
@@ -320,175 +377,207 @@ ruleTester.run('return-await', rule, {
     },
     {
       options: ['in-try-catch'],
-      code: `async function test() {
-        try {
-          return Promise.resolve(1);
-        } catch (e) {
-          return Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      code: `
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
-      output: `async function test() {
-        try {
-          return await Promise.resolve(1);
-        } catch (e) {
-          return await Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      `,
+      output: `
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
+      `,
       errors: [
         {
-          line: 3,
+          line: 4,
           messageId: 'requiredPromiseAwait',
         },
         {
-          line: 5,
+          line: 6,
           messageId: 'requiredPromiseAwait',
         },
       ],
     },
     {
       options: ['in-try-catch'],
-      code: `async function test() {
-        return await Promise.resolve(1);
-      }`,
-      output: `async function test() {
-        return Promise.resolve(1);
-      }`,
+      code: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
+      output: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'disallowedPromiseAwait',
         },
       ],
     },
     {
       options: ['never'],
-      code: `async function test() {
-        return await 1;
-      }`,
-      output: `async function test() {
-        return 1;
-      }`,
+      code: `
+        async function test() {
+          return await 1;
+        }
+      `,
+      output: `
+        async function test() {
+          return 1;
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'nonPromiseAwait',
         },
       ],
     },
     {
       options: ['never'],
-      code: `async function test() {
-        try {
-          return await Promise.resolve(1);
-        } catch (e) {
-          return await Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      code: `
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
-      output: `async function test() {
-        try {
-          return Promise.resolve(1);
-        } catch (e) {
-          return Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      `,
+      output: `
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
+      `,
       errors: [
         {
-          line: 3,
+          line: 4,
           messageId: 'disallowedPromiseAwait',
         },
         {
-          line: 5,
+          line: 6,
           messageId: 'disallowedPromiseAwait',
         },
       ],
     },
     {
       options: ['never'],
-      code: `async function test() {
-        return await Promise.resolve(1);
-      }`,
-      output: `async function test() {
-        return Promise.resolve(1);
-      }`,
+      code: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
+      output: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'disallowedPromiseAwait',
         },
       ],
     },
     {
       options: ['always'],
-      code: `async function test() {
-        return await 1;
-      }`,
-      output: `async function test() {
-        return 1;
-      }`,
+      code: `
+        async function test() {
+          return await 1;
+        }
+      `,
+      output: `
+        async function test() {
+          return 1;
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'nonPromiseAwait',
         },
       ],
     },
     {
       options: ['always'],
-      code: `async function test() {
-        try {
-          return Promise.resolve(1);
-        } catch (e) {
-          return Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      code: `
+        async function test() {
+          try {
+            return Promise.resolve(1);
+          } catch (e) {
+            return Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
-      output: `async function test() {
-        try {
-          return await Promise.resolve(1);
-        } catch (e) {
-          return await Promise.resolve(2);
-        } finally {
-          console.log('cleanup');
+      `,
+      output: `
+        async function test() {
+          try {
+            return await Promise.resolve(1);
+          } catch (e) {
+            return await Promise.resolve(2);
+          } finally {
+            console.log('cleanup');
+          }
         }
-      }`,
+      `,
       errors: [
         {
-          line: 3,
+          line: 4,
           messageId: 'requiredPromiseAwait',
         },
         {
-          line: 5,
+          line: 6,
           messageId: 'requiredPromiseAwait',
         },
       ],
     },
     {
       options: ['always'],
-      code: `async function test() {
-        return Promise.resolve(1);
-      }`,
-      output: `async function test() {
-        return await Promise.resolve(1);
-      }`,
+      code: `
+        async function test() {
+          return Promise.resolve(1);
+        }
+      `,
+      output: `
+        async function test() {
+          return await Promise.resolve(1);
+        }
+      `,
       errors: [
         {
-          line: 2,
+          line: 3,
           messageId: 'requiredPromiseAwait',
         },
       ],
     },
     {
       options: ['always'],
-      code: `const test = async () => Promise.resolve(1);`,
+      code: 'const test = async () => Promise.resolve(1);',
       errors: [
         {
           line: 1,
diff --git a/packages/eslint-plugin/tests/rules/semi.test.ts b/packages/eslint-plugin/tests/rules/semi.test.ts
index 95f22986b10..c8a8ff7f479 100644
--- a/packages/eslint-plugin/tests/rules/semi.test.ts
+++ b/packages/eslint-plugin/tests/rules/semi.test.ts
@@ -133,129 +133,129 @@ class PanCamera extends FreeCamera {
       // https://github.com/eslint/eslint/issues/9521
       {
         code: `
-                do; while(a);
-                [1,2,3].forEach(doSomething)
-            `,
+          do; while(a);
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'any' }],
       },
       {
         code: `
-                do; while(a)
-                [1,2,3].forEach(doSomething)
-            `,
+          do; while(a)
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'any' }],
       },
       {
         code: `
-                import a from "a";
-                [1,2,3].forEach(doSomething)
-            `,
+          import a from "a";
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
       },
       {
         code: `
-                var a = 0; export {a};
-                [a] = b
-            `,
+          var a = 0; export {a};
+          [a] = b
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
       },
       {
         code: `
-                function wrap() {
-                    return;
-                    ({a} = b)
-                }
-            `,
+          function wrap() {
+            return;
+            ({a} = b)
+          }
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
         parserOptions: { ecmaVersion: 2015 },
       },
       {
         code: `
-                while (true) {
-                    break;
-                    +i
-                }
-            `,
+          while (true) {
+            break;
+            +i
+          }
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
       },
       {
         code: `
-                while (true) {
-                    continue;
-                    [1,2,3].forEach(doSomething)
-                }
-            `,
+          while (true) {
+            continue;
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
       },
       {
         code: `
-                do; while(a);
-                [1,2,3].forEach(doSomething)
-            `,
+          do; while(a);
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
       },
       {
         code: `
-                const f = () => {};
-                [1,2,3].forEach(doSomething)
-            `,
+          const f = () => {};
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
         parserOptions: { ecmaVersion: 2015 },
       },
       {
         code: `
-                import a from "a"
-                [1,2,3].forEach(doSomething)
-            `,
+          import a from "a"
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
       },
       {
         code: `
-                var a = 0; export {a}
-                [a] = b
-            `,
+          var a = 0; export {a}
+          [a] = b
+        `,
         options: neverOptionWithoutContinuationChars,
       },
       {
         code: `
-                function wrap() {
-                    return
-                    ({a} = b)
-                }
-            `,
+          function wrap() {
+            return
+            ({a} = b)
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
         parserOptions: { ecmaVersion: 2015 },
       },
       {
         code: `
-                while (true) {
-                    break
-                    +i
-                }
-            `,
+          while (true) {
+            break
+            +i
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
       },
       {
         code: `
-                while (true) {
-                    continue
-                    [1,2,3].forEach(doSomething)
-                }
-            `,
+          while (true) {
+            continue
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
       },
       {
         code: `
-                do; while(a)
-                [1,2,3].forEach(doSomething)
-            `,
+          do; while(a)
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
       },
       {
         code: `
-                const f = () => {}
-                [1,2,3].forEach(doSomething)
-            `,
+          const f = () => {}
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
         parserOptions: { ecmaVersion: 2015 },
       },
@@ -665,11 +665,11 @@ class PanCamera extends FreeCamera {
 
       {
         code: `
-      import a from "a"
-      (function() {
-          // ...
-      })()
-      `,
+          import a from "a"
+          (function() {
+              // ...
+          })()
+        `,
         options: [
           'never',
           { beforeStatementContinuationChars: 'always' },
@@ -678,11 +678,11 @@ class PanCamera extends FreeCamera {
       },
       {
         code: `
-      import a from "a"
-      ;(function() {
-          // ...
-      })()
-      `,
+          import a from "a"
+          ;(function() {
+              // ...
+          })()
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
@@ -767,299 +767,299 @@ class PanCamera extends FreeCamera {
       // https://github.com/eslint/eslint/issues/9521
       {
         code: `
-                      import a from "a"
-                      [1,2,3].forEach(doSomething)
-                  `,
+          import a from "a"
+          [1,2,3].forEach(doSomething)
+        `,
         output: `
-                      import a from "a";
-                      [1,2,3].forEach(doSomething)
-                  `,
+          import a from "a";
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
 
         errors: ['Missing semicolon.'],
       },
       {
         code: `
-                      var a = 0; export {a}
-                      [a] = b
-                  `,
+          var a = 0; export {a}
+          [a] = b
+        `,
         output: `
-                      var a = 0; export {a};
-                      [a] = b
-                  `,
+          var a = 0; export {a};
+          [a] = b
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
 
         errors: ['Missing semicolon.'],
       },
       {
         code: `
-                      function wrap() {
-                          return
-                          ({a} = b)
-                      }
-                  `,
+          function wrap() {
+            return
+            ({a} = b)
+          }
+        `,
         output: `
-                      function wrap() {
-                          return;
-                          ({a} = b)
-                      }
-                  `,
+          function wrap() {
+            return;
+            ({a} = b)
+          }
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
         parserOptions: { ecmaVersion: 2015 },
         errors: ['Missing semicolon.'],
       },
       {
         code: `
-                      while (true) {
-                          break
-                         +i
-                      }
-                  `,
+          while (true) {
+            break
+            +i
+          }
+        `,
         output: `
-                      while (true) {
-                          break;
-                         +i
-                      }
-                  `,
+          while (true) {
+            break;
+            +i
+          }
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
         errors: ['Missing semicolon.'],
       },
       {
         code: `
-                      while (true) {
-                          continue
-                          [1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            continue
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         output: `
-                      while (true) {
-                          continue;
-                          [1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            continue;
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
         errors: ['Missing semicolon.'],
       },
       {
         code: `
-                      do; while(a)
-                      [1,2,3].forEach(doSomething)
-                  `,
+          do; while(a)
+          [1,2,3].forEach(doSomething)
+        `,
         output: `
-                      do; while(a);
-                      [1,2,3].forEach(doSomething)
-                  `,
+          do; while(a);
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
         errors: ['Missing semicolon.'],
       },
       {
         code: `
-                      const f = () => {}
-                      [1,2,3].forEach(doSomething)
-                  `,
+          const f = () => {}
+          [1,2,3].forEach(doSomething)
+        `,
         output: `
-                      const f = () => {};
-                      [1,2,3].forEach(doSomething)
-                  `,
+          const f = () => {};
+          [1,2,3].forEach(doSomething)
+        `,
         options: ['never', { beforeStatementContinuationChars: 'always' }],
         parserOptions: { ecmaVersion: 2015 },
         errors: ['Missing semicolon.'],
       },
       {
         code: `
-                      import a from "a";
-                      [1,2,3].forEach(doSomething)
-                  `,
+          import a from "a";
+          [1,2,3].forEach(doSomething)
+        `,
         output: `
-                      import a from "a"
-                      [1,2,3].forEach(doSomething)
-                  `,
+          import a from "a"
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
 
         errors: [extraSemicolon],
       },
       {
         code: `
-                      var a = 0; export {a};
-                      [a] = b
-                  `,
+          var a = 0; export {a};
+          [a] = b
+        `,
         output: `
-                      var a = 0; export {a}
-                      [a] = b
-                  `,
+          var a = 0; export {a}
+          [a] = b
+        `,
         options: neverOptionWithoutContinuationChars,
 
         errors: [extraSemicolon],
       },
       {
         code: `
-                      function wrap() {
-                          return;
-                          ({a} = b)
-                      }
-                  `,
+          function wrap() {
+            return;
+            ({a} = b)
+          }
+        `,
         output: `
-                      function wrap() {
-                          return
-                          ({a} = b)
-                      }
-                  `,
+          function wrap() {
+            return
+            ({a} = b)
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
         parserOptions: { ecmaVersion: 2015 },
         errors: [extraSemicolon],
       },
       {
         code: `
-                      while (true) {
-                          break;
-                          +i
-                      }
-                  `,
+          while (true) {
+            break;
+            +i
+          }
+        `,
         output: `
-                      while (true) {
-                          break
-                          +i
-                      }
-                  `,
+          while (true) {
+            break
+            +i
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
       {
         code: `
-                      while (true) {
-                          continue;
-                          [1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            continue;
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         output: `
-                      while (true) {
-                          continue
-                          [1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            continue
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
       {
         code: `
-                      do; while(a);
-                      [1,2,3].forEach(doSomething)
-                  `,
+          do; while(a);
+          [1,2,3].forEach(doSomething)
+        `,
         output: `
-                      do; while(a)
-                      [1,2,3].forEach(doSomething)
-                  `,
+          do; while(a)
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
       {
         code: `
-                      const f = () => {};
-                      [1,2,3].forEach(doSomething)
-                  `,
+          const f = () => {};
+          [1,2,3].forEach(doSomething)
+        `,
         output: `
-                      const f = () => {}
-                      [1,2,3].forEach(doSomething)
-                  `,
+          const f = () => {}
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
         parserOptions: { ecmaVersion: 2015 },
         errors: [extraSemicolon],
       },
       {
         code: `
-                      import a from "a"
-                      ;[1,2,3].forEach(doSomething)
-                  `,
+          import a from "a"
+          ;[1,2,3].forEach(doSomething)
+        `,
         output: `
-                      import a from "a"
-                      [1,2,3].forEach(doSomething)
-                  `,
+          import a from "a"
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
 
         errors: [extraSemicolon],
       },
       {
         code: `
-                      var a = 0; export {a}
-                      ;[1,2,3].forEach(doSomething)
-                  `,
+          var a = 0; export {a}
+          ;[1,2,3].forEach(doSomething)
+        `,
         output: `
-                      var a = 0; export {a}
-                      [1,2,3].forEach(doSomething)
-                  `,
+          var a = 0; export {a}
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
 
         errors: [extraSemicolon],
       },
       {
         code: `
-                      function wrap() {
-                          return
-                          ;[1,2,3].forEach(doSomething)
-                      }
-                  `,
+          function wrap() {
+            return
+            ;[1,2,3].forEach(doSomething)
+          }
+        `,
         output: `
-                      function wrap() {
-                          return
-                          [1,2,3].forEach(doSomething)
-                      }
-                  `,
+          function wrap() {
+            return
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
       {
         code: `
-                      while (true) {
-                          break
-                          ;[1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            break
+            ;[1,2,3].forEach(doSomething)
+          }
+        `,
         output: `
-                      while (true) {
-                          break
-                          [1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            break
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
       {
         code: `
-                      while (true) {
-                          continue
-                          ;[1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            continue
+            ;[1,2,3].forEach(doSomething)
+          }
+        `,
         output: `
-                      while (true) {
-                          continue
-                          [1,2,3].forEach(doSomething)
-                      }
-                  `,
+          while (true) {
+            continue
+            [1,2,3].forEach(doSomething)
+          }
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
       {
         code: `
-                      do; while(a)
-                      ;[1,2,3].forEach(doSomething)
-                  `,
+          do; while(a)
+          ;[1,2,3].forEach(doSomething)
+        `,
         output: `
-                      do; while(a)
-                      [1,2,3].forEach(doSomething)
-                  `,
+          do; while(a)
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
         errors: [extraSemicolon],
       },
       {
         code: `
-                      const f = () => {}
-                      ;[1,2,3].forEach(doSomething)
-                  `,
+          const f = () => {}
+          ;[1,2,3].forEach(doSomething)
+        `,
         output: `
-                      const f = () => {}
-                      [1,2,3].forEach(doSomething)
-                  `,
+          const f = () => {}
+          [1,2,3].forEach(doSomething)
+        `,
         options: neverOptionWithoutContinuationChars,
         parserOptions: { ecmaVersion: 2015 },
         errors: [extraSemicolon],
diff --git a/packages/eslint-plugin/tests/rules/space-before-function-paren.test.ts b/packages/eslint-plugin/tests/rules/space-before-function-paren.test.ts
index 7acb61fa85f..eb515c1617c 100644
--- a/packages/eslint-plugin/tests/rules/space-before-function-paren.test.ts
+++ b/packages/eslint-plugin/tests/rules/space-before-function-paren.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the spacing, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import {
   TSESLint,
   AST_NODE_TYPES,
diff --git a/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts b/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
index d3d5700c5a7..daa619b84ee 100644
--- a/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/strict-boolean-expressions.test.ts
@@ -3,6 +3,7 @@ import {
   RuleTester,
   getFixturesRootDir,
   batchedSingleLineTests,
+  noFormat,
 } from '../RuleTester';
 
 const rootPath = getFixturesRootDir();
@@ -48,7 +49,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
         return;
       }
 
-      if ((bool1 && bool2) || (bool1 || bool2)) {
+      if ((bool1 && bool2) || bool1 || bool2) {
         return;
       }
     `,
@@ -58,7 +59,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
       const res1 = true ? true : false;
       const res2 = bool1 && bool2 ? true : false;
       const res3 = bool1 || bool2 ? true : false;
-      const res4 = (bool1 && bool2) || (bool1 || bool2) ? true : false;
+      const res4 = (bool1 && bool2) || bool1 || bool2 ? true : false;
     `,
     `
       for (let i = 0; true; i++) {
@@ -88,7 +89,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
     `
       const bool1 = true;
       const bool2 = false;
-      for (let i = 0; (bool1 && bool2) || (bool1 || bool2); i++) {
+      for (let i = 0; (bool1 && bool2) || bool1 || bool2; i++) {
         break;
       }
     `,
@@ -120,7 +121,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
     `
       const bool1 = true;
       const bool2 = false;
-      while ((bool1 && bool2) || (bool1 || bool2)) {
+      while ((bool1 && bool2) || bool1 || bool2) {
         break;
       }
     `,
@@ -154,10 +155,12 @@ ruleTester.run('strict-boolean-expressions', rule, {
       const bool2 = false;
       do {
         break;
-      } while ((bool1 && bool2) || (bool1 || bool2));
+      } while ((bool1 && bool2) || bool1 || bool2);
     `,
     `
-      function foo<T extends boolean>(arg: T) { return !arg; }
+      function foo<T extends boolean>(arg: T) {
+        return !arg;
+      }
     `,
     {
       options: [{ ignoreRhs: true }],
@@ -171,10 +174,10 @@ ruleTester.run('strict-boolean-expressions', rule, {
     ...batchedSingleLineTests({
       options: [{ allowNullable: true }],
       code: `
-        const f1 = (x?: boolean) => x ? 1 : 0;
-        const f2 = (x: boolean | null) => x ? 1 : 0;
-        const f3 = (x?: true | null) => x ? 1 : 0;
-        const f4 = (x?: false) => x ? 1 : 0;
+        const f1 = (x?: boolean) => (x ? 1 : 0);
+        const f2 = (x: boolean | null) => (x ? 1 : 0);
+        const f3 = (x?: true | null) => (x ? 1 : 0);
+        const f4 = (x?: false) => (x ? 1 : 0);
       `,
     }),
     `
@@ -184,38 +187,39 @@ ruleTester.run('strict-boolean-expressions', rule, {
     ...batchedSingleLineTests({
       options: [{ allowSafe: true }],
       code: `
-        const f1 = (x: boolean | { a: string }) => x ? 1 : 0;
-        const f2 = (x: true | { a: string }) => x ? 1 : 0;
-        const f3 = (x: { a: string } | false) => x ? 1 : 0;
+        const f1 = (x: boolean | { a: string }) => (x ? 1 : 0);
+        const f2 = (x: true | { a: string }) => (x ? 1 : 0);
+        const f3 = (x: { a: string } | false) => (x ? 1 : 0);
       `,
     }),
     ...batchedSingleLineTests({
       options: [{ allowNullable: true, allowSafe: true }],
       code: `
-        const f1 = (x?: boolean | { a?: 1 }) => x ? 1 : 0;
-        const f2 = (x: { a?: 1 } | { b?: "a" } | null) => x ? 1 : 0;
-        const f3 = (x?: { a?: 1 } | { b?: "a" } | null) => x ? 1 : 0;
-        const f4 = (x?: { b?: "a" } | true) => x ? 1 : 0;
-        const f5 = (g?: (x: number) => number) => g ? g(1) : 0;
+        const f1 = (x?: boolean | { a?: 1 }) => (x ? 1 : 0);
+        const f2 = (x: { a?: 1 } | { b?: 'a' } | null) => (x ? 1 : 0);
+        const f3 = (x?: { a?: 1 } | { b?: 'a' } | null) => (x ? 1 : 0);
+        const f4 = (x?: { b?: 'a' } | true) => (x ? 1 : 0);
+        const f5 = (g?: (x: number) => number) => (g ? g(1) : 0);
       `,
     }),
     ...batchedSingleLineTests({
       options: [{ allowNullable: true, allowSafe: true, ignoreRhs: true }],
       code: `
-        const f1 = (x?: { a: null }) => x && x.foo && x.foo.bar
-        const f2 = (g?: (x: number) => number) => g && g(1)
+        const f1 = (x?: { a: null }) => x && x.foo && x.foo.bar;
+        const f2 = (g?: (x: number) => number) => g && g(1);
       `,
     }),
     `
       declare let x: never;
-      if (x) {}
+      if (x) {
+      }
     `,
     ...batchedSingleLineTests({
-      code: `
-        function f1(x: never) { return !x }
-        function f2(x: never) { return x ? 1 : 0 }
-        function f3(x: never, y: never) { return x && y }
-        function f5(x: never | boolean) { if (!x) {} }
+      code: noFormat`
+        function f1(x: never) { return !x; }
+        function f2(x: never) { return x ? 1 : 0; }
+        function f3(x: never, y: never) { return x && y; }
+        function f5(x: never | boolean) { if (!x) { } }
       `,
     }),
   ],
@@ -223,7 +227,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
   invalid: [
     {
       code: `
-        let val = "foo";
+        let val = 'foo';
         let bool = !val;
       `,
       errors: [
@@ -302,7 +306,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
     {
       code: `
         let num = 1;
-        let str = "foo"
+        let str = 'foo';
         let val = null;
         let bool = true && (val || num || str);
       `,
@@ -354,7 +358,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
     },
     {
       code: `
-        let item = "foo";
+        let item = 'foo';
         if (item) {
           return;
         }
@@ -480,7 +484,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
     },
     {
       code: `
-        const bool = "foo" ? true : false;
+        const bool = 'foo' ? true : false;
       `,
       errors: [
         {
@@ -672,7 +676,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
     },
     {
       code: `
-        let bool1 = "foo";
+        let bool1 = 'foo';
         let bool2 = true;
         for (let i = 0; bool1 && bool2; i++) {
           return;
@@ -860,7 +864,7 @@ ruleTester.run('strict-boolean-expressions', rule, {
       code: `
         do {
           return;
-        } while ("foo");
+        } while ('foo');
       `,
       errors: [
         {
@@ -980,13 +984,15 @@ ruleTester.run('strict-boolean-expressions', rule, {
     },
     {
       code: `
-        function foo<T extends number>(arg: T) { return !arg; }
+        function foo<T extends number>(arg: T) {
+          return !arg;
+        }
       `,
       errors: [
         {
           messageId: 'conditionErrorNumber',
-          line: 2,
-          column: 58,
+          line: 3,
+          column: 19,
         },
       ],
     },
@@ -995,23 +1001,23 @@ ruleTester.run('strict-boolean-expressions', rule, {
         {
           messageId: 'conditionErrorNullableBoolean',
           line: 2,
-          column: 47,
+          column: 48,
         },
         {
           messageId: 'conditionErrorNullableBoolean',
           line: 3,
-          column: 37,
+          column: 38,
         },
         {
           messageId: 'conditionErrorOther',
           line: 4,
-          column: 41,
+          column: 42,
         },
       ],
       code: `
-        const f1 = (x: boolean | null | undefined) => x ? 1 : 0;
-        const f2 = (x?: boolean) => x ? 1 : 0;
-        const f3 = (x: boolean | {}) => x ? 1 : 0;
+        const f1 = (x: boolean | null | undefined) => (x ? 1 : 0);
+        const f2 = (x?: boolean) => (x ? 1 : 0);
+        const f3 = (x: boolean | {}) => (x ? 1 : 0);
       `,
     }),
     {
@@ -1045,15 +1051,17 @@ ruleTester.run('strict-boolean-expressions', rule, {
         },
         {
           messageId: 'conditionErrorOther',
-          line: 5,
+          line: 6,
           column: 13,
         },
       ],
       code: `
         const condition = () => false;
         const obj = { x: 1 };
-        if (condition() || obj) {}
-        if (condition() && obj) {}
+        if (condition() || obj) {
+        }
+        if (condition() && obj) {
+        }
       `,
     },
     {
@@ -1066,15 +1074,17 @@ ruleTester.run('strict-boolean-expressions', rule, {
         },
         {
           messageId: 'conditionErrorOther',
-          line: 5,
+          line: 6,
           column: 13,
         },
       ],
       code: `
         declare let condition: boolean;
         const obj = { x: 1 };
-        if (condition || obj) {}
-        if (condition && obj) {}
+        if (condition || obj) {
+        }
+        if (condition && obj) {
+        }
       `,
     },
     ...batchedSingleLineTests({
@@ -1083,29 +1093,29 @@ ruleTester.run('strict-boolean-expressions', rule, {
         {
           messageId: 'conditionErrorNullish',
           line: 2,
-          column: 37,
+          column: 38,
         },
         {
           messageId: 'conditionErrorNullableNumber',
           line: 3,
-          column: 36,
+          column: 37,
         },
         {
           messageId: 'conditionErrorNullableString',
           line: 4,
-          column: 36,
+          column: 37,
         },
         {
           messageId: 'conditionErrorOther',
           line: 5,
-          column: 45,
+          column: 46,
         },
       ],
       code: `
-        const f1 = (x: null | undefined) => x ? 1 : 0;
-        const f2 = (x?: number) => x ? 1 : 0;
-        const f3 = (x?: string) => x ? 1 : 0;
-        const f4 = (x?: string | number) => x ? 1 : 0;
+        const f1 = (x: null | undefined) => (x ? 1 : 0);
+        const f2 = (x?: number) => (x ? 1 : 0);
+        const f3 = (x?: string) => (x ? 1 : 0);
+        const f4 = (x?: string | number) => (x ? 1 : 0);
       `,
     }),
     {
@@ -1113,18 +1123,18 @@ ruleTester.run('strict-boolean-expressions', rule, {
         {
           messageId: 'conditionErrorOther',
           line: 3,
-          column: 43,
+          column: 44,
         },
         {
           messageId: 'conditionErrorOther',
           line: 4,
-          column: 44,
+          column: 45,
         },
       ],
       code: `
-        type Type = { a: string; };
-        const f1 = (x: Type | boolean) => x ? 1 : 0;
-        const f2 = (x?: Type | boolean) => x ? 1 : 0;
+        type Type = { a: string };
+        const f1 = (x: Type | boolean) => (x ? 1 : 0);
+        const f2 = (x?: Type | boolean) => (x ? 1 : 0);
       `,
     },
     ...batchedSingleLineTests({
@@ -1133,23 +1143,23 @@ ruleTester.run('strict-boolean-expressions', rule, {
         {
           messageId: 'conditionErrorOther',
           line: 2,
-          column: 36,
+          column: 37,
         },
         {
           messageId: 'conditionErrorOther',
           line: 3,
-          column: 44,
+          column: 45,
         },
         {
           messageId: 'conditionErrorOther',
           line: 4,
-          column: 44,
+          column: 45,
         },
       ],
       code: `
-        const f1 = (x: object | string) => x ? 1 : 0;
-        const f2 = (x: object | number) => x ? 1 : 0;
-        const f3 = (x: number | string) => x ? 1 : 0;
+        const f1 = (x: object | string) => (x ? 1 : 0);
+        const f2 = (x: object | number) => (x ? 1 : 0);
+        const f3 = (x: number | string) => (x ? 1 : 0);
       `,
     }),
     {
@@ -1157,24 +1167,28 @@ ruleTester.run('strict-boolean-expressions', rule, {
       errors: [
         {
           messageId: 'conditionErrorNumber',
-          line: 8,
-          column: 34,
+          line: 12,
+          column: 35,
         },
         {
           messageId: 'conditionErrorString',
-          line: 9,
-          column: 34,
+          line: 13,
+          column: 35,
         },
       ],
       code: `
         enum Enum1 {
-          A, B, C
+          A,
+          B,
+          C,
         }
         enum Enum2 {
-          A = 'A', B = 'B', C = 'C'
+          A = 'A',
+          B = 'B',
+          C = 'C',
         }
-        const f1 = (x: Enum1) => x ? 1 : 0;
-        const f2 = (x: Enum2) => x ? 1 : 0;
+        const f1 = (x: Enum1) => (x ? 1 : 0);
+        const f2 = (x: Enum2) => (x ? 1 : 0);
       `,
     },
     {
@@ -1183,18 +1197,18 @@ ruleTester.run('strict-boolean-expressions', rule, {
         {
           messageId: 'conditionErrorOther',
           line: 3,
-          column: 43,
+          column: 44,
         },
         {
           messageId: 'conditionErrorOther',
           line: 4,
-          column: 49,
+          column: 50,
         },
       ],
       code: `
-        type Type = { a: string; };
-        const f1 = (x?: Type | string) => x ? 1 : 0;
-        const f2 = (x: Type | number | null) => x ? 1 : 0;
+        type Type = { a: string };
+        const f1 = (x?: Type | string) => (x ? 1 : 0);
+        const f2 = (x: Type | number | null) => (x ? 1 : 0);
       `,
     },
     ...batchedSingleLineTests({
@@ -1202,23 +1216,23 @@ ruleTester.run('strict-boolean-expressions', rule, {
         {
           messageId: 'conditionErrorObject',
           line: 2,
-          column: 31,
+          column: 32,
         },
         {
           messageId: 'conditionErrorNullableObject',
           line: 3,
-          column: 40,
+          column: 41,
         },
         {
           messageId: 'conditionErrorNullableObject',
           line: 4,
-          column: 47,
+          column: 48,
         },
       ],
       code: `
-        const f1 = (x: { x: any }) => x ? 1 : 0;
-        const f2 = (x?: { x: any }) => x ? 1 : 0;
-        const f3 = (x?: { x: any } | null) => x ? 1 : 0;
+        const f1 = (x: { x: any }) => (x ? 1 : 0);
+        const f2 = (x?: { x: any }) => (x ? 1 : 0);
+        const f3 = (x?: { x: any } | null) => (x ? 1 : 0);
       `,
     }),
   ],
diff --git a/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts b/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
index fd9462ddb1e..3eb47fb6eb9 100644
--- a/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
+++ b/packages/eslint-plugin/tests/rules/switch-exhaustiveness-check.test.ts
@@ -1,6 +1,6 @@
 import path from 'path';
 import switchExhaustivenessCheck from '../../src/rules/switch-exhaustiveness-check';
-import { RuleTester } from '../RuleTester';
+import { RuleTester, noFormat } from '../RuleTester';
 
 const rootPath = path.join(process.cwd(), 'tests/fixtures/');
 
@@ -16,183 +16,226 @@ ruleTester.run('switch-exhaustiveness-check', switchExhaustivenessCheck, {
   valid: [
     // All branches matched
     `
-type Day = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday'
-
-const day = 'Monday' as Day
-let result = 0
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
 
 switch (day) {
   case 'Monday': {
-     result = 1
-     break
+    result = 1;
+    break;
   }
   case 'Tuesday': {
-     result = 2
-     break
+    result = 2;
+    break;
   }
   case 'Wednesday': {
-     result = 3
-     break
+    result = 3;
+    break;
   }
   case 'Thursday': {
-     result = 4
-     break
+    result = 4;
+    break;
   }
   case 'Friday': {
-     result = 5
-     break
+    result = 5;
+    break;
   }
   case 'Saturday': {
-     result = 6
-     break
+    result = 6;
+    break;
   }
   case 'Sunday': {
-     result = 7
-     break
+    result = 7;
+    break;
   }
 }
-`,
+    `,
     // Other primitive literals work too
     `
-type Num = 0 | 1 | 2
+type Num = 0 | 1 | 2;
 
 function test(value: Num): number {
   switch (value) {
-    case 0: return 0
-    case 1: return 1
-    case 2: return 2
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    case 2:
+      return 2;
   }
 }
-`,
+    `,
     `
-type Bool = true | false
+type Bool = true | false;
 
 function test(value: Bool): number {
   switch (value) {
-    case true: return 1
-    case false: return 0
+    case true:
+      return 1;
+    case false:
+      return 0;
   }
 }
-`,
+    `,
     `
-type Mix = 0 | 1 | 'two' | 'three' | true
+type Mix = 0 | 1 | 'two' | 'three' | true;
 
 function test(value: Mix): number {
   switch (value) {
-    case 0: return 0
-    case 1: return 1
-    case 'two': return 2
-    case 'three': return 3
-    case true: return 4
+    case 0:
+      return 0;
+    case 1:
+      return 1;
+    case 'two':
+      return 2;
+    case 'three':
+      return 3;
+    case true:
+      return 4;
   }
 }
-`,
+    `,
     // Works with type references
     `
-type A = 'a'
-type B = 'b'
-type C = 'c'
-type Union = A | B | C
+type A = 'a';
+type B = 'b';
+type C = 'c';
+type Union = A | B | C;
 
 function test(value: Union): number {
   switch (value) {
-    case 'a': return 1
-    case 'b': return 2
-    case 'c': return 3
+    case 'a':
+      return 1;
+    case 'b':
+      return 2;
+    case 'c':
+      return 3;
   }
 }
-`,
+    `,
     // Works with `typeof`
     `
-const A = 'a'
-const B = 1
-const C = true
+const A = 'a';
+const B = 1;
+const C = true;
 
-type Union = typeof A | typeof B | typeof C
+type Union = typeof A | typeof B | typeof C;
 
 function test(value: Union): number {
   switch (value) {
-    case 'a': return 1
-    case 1: return 2
-    case true: return 3
+    case 'a':
+      return 1;
+    case 1:
+      return 2;
+    case true:
+      return 3;
   }
 }
-`,
+    `,
     // Switch contains default clause.
     `
-type Day = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday'
-
-const day = 'Monday' as Day
-let result = 0
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
 
 switch (day) {
   case 'Monday': {
-     result = 1
-     break
+    result = 1;
+    break;
   }
   default: {
-     result = 42
+    result = 42;
   }
 }
-  `,
+    `,
     // Exhaustiveness check only works for union types...
     `
-const day = 'Monday' as string
-let result = 0
+const day = 'Monday' as string;
+let result = 0;
 
 switch (day) {
   case 'Monday': {
-    result = 1
-    break
+    result = 1;
+    break;
   }
   case 'Tuesday': {
-    result = 2
-    break
+    result = 2;
+    break;
   }
 }
-  `,
+    `,
     // ... and enums (at least for now).
     `
-enum Enum { A, B }
+enum Enum {
+  A,
+  B,
+}
 
 function test(value: Enum): number {
   switch (value) {
-    case Enum.A: return 1
-    case Enum.B: return 2
+    case Enum.A:
+      return 1;
+    case Enum.B:
+      return 2;
   }
 }
-`,
+    `,
     // Object union types won't work either, unless it's a discriminated union
     `
-type ObjectUnion = { a: 1 } | { b: 2 }
+type ObjectUnion = { a: 1 } | { b: 2 };
 
 function test(value: ObjectUnion): number {
   switch (value.a) {
-    case 1: return 1
+    case 1:
+      return 1;
   }
 }
-`,
+    `,
   ],
   invalid: [
     {
       // Matched only one branch out of seven.
       code: `
-type Day = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday'
-
-const day = 'Monday' as Day
-let result = 0
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
+
+const day = 'Monday' as Day;
+let result = 0;
 
 switch (day) {
   case 'Monday': {
-     result = 1
-     break
+    result = 1;
+    break;
   }
 }
-`,
+      `,
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 7,
+          line: 14,
           column: 9,
           data: {
             missingBranches:
@@ -204,18 +247,22 @@ switch (day) {
     {
       // Didn't match all enum variants
       code: `
-enum Enum { A, B }
+enum Enum {
+  A,
+  B,
+}
 
 function test(value: Enum): number {
   switch (value) {
-    case Enum.A: return 1
+    case Enum.A:
+      return 1;
   }
 }
-`,
+      `,
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 5,
+          line: 8,
           column: 11,
           data: {
             missingBranches: 'Enum.B',
@@ -225,17 +272,18 @@ function test(value: Enum): number {
     },
     {
       code: `
-type A = 'a'
-type B = 'b'
-type C = 'c'
-type Union = A | B | C
+type A = 'a';
+type B = 'b';
+type C = 'c';
+type Union = A | B | C;
 
 function test(value: Union): number {
   switch (value) {
-    case 'a': return 1
+    case 'a':
+      return 1;
   }
 }
-`,
+      `,
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
@@ -249,18 +297,19 @@ function test(value: Union): number {
     },
     {
       code: `
-const A = 'a'
-const B = 1
-const C = true
+const A = 'a';
+const B = 1;
+const C = true;
 
-type Union = typeof A | typeof B | typeof C
+type Union = typeof A | typeof B | typeof C;
 
 function test(value: Union): number {
   switch (value) {
-    case 'a': return 1
+    case 'a':
+      return 1;
   }
 }
-`,
+      `,
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
@@ -274,14 +323,15 @@ function test(value: Union): number {
     },
     {
       code: `
-type DiscriminatedUnion = { type: 'A', a: 1 } | { type: 'B', b: 2 }
+type DiscriminatedUnion = { type: 'A'; a: 1 } | { type: 'B'; b: 2 };
 
 function test(value: DiscriminatedUnion): number {
   switch (value.type) {
-    case 'A': return 1
+    case 'A':
+      return 1;
   }
 }
-`,
+      `,
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
@@ -296,17 +346,24 @@ function test(value: DiscriminatedUnion): number {
     {
       // Still complains with empty switch
       code: `
-type Day = 'Monday' | 'Tuesday' | 'Wednesday' | 'Thursday' | 'Friday' | 'Saturday' | 'Sunday'
+type Day =
+  | 'Monday'
+  | 'Tuesday'
+  | 'Wednesday'
+  | 'Thursday'
+  | 'Friday'
+  | 'Saturday'
+  | 'Sunday';
 
-const day = 'Monday' as Day
+const day = 'Monday' as Day;
 
 switch (day) {
 }
-`,
+      `,
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
-          line: 6,
+          line: 13,
           column: 9,
           data: {
             missingBranches:
@@ -318,15 +375,15 @@ switch (day) {
     {
       // Still complains with union intersection part
       code: `
-type FooBar = string & { foo: void } | 'bar'
+type FooBar = (string & { foo: void }) | 'bar';
 
-const foobar = 'bar' as FooBar
-let result = 0
+const foobar = 'bar' as FooBar;
+let result = 0;
 
 switch (foobar) {
   case 'bar': {
-    result = 42
-    break
+    result = 42;
+    break;
   }
 }
       `,
@@ -343,15 +400,16 @@ switch (foobar) {
     },
     {
       code: `
-const a = Symbol('a')
-const b = Symbol('b')
-const c = Symbol('c')
+const a = Symbol('a');
+const b = Symbol('b');
+const c = Symbol('c');
 
-type T = typeof a | typeof b | typeof c
+type T = typeof a | typeof b | typeof c;
 
 function test(value: T): number {
   switch (value) {
-    case a: return 1;
+    case a:
+      return 1;
   }
 }
       `,
@@ -370,30 +428,32 @@ function test(value: T): number {
     {
       // with existing cases present
       code: `
-type T = 1 | 2
+type T = 1 | 2;
 
 function test(value: T): number {
   switch (value) {
-    case 1: return 1;
+    case 1:
+      return 1;
   }
 }
-      `,
+      `.trimRight(),
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
-              output: `
-type T = 1 | 2
+              output: noFormat`
+type T = 1 | 2;
 
 function test(value: T): number {
   switch (value) {
-    case 1: return 1;
+    case 1:
+      return 1;
     case 2: { throw new Error('Not implemented yet: 2 case') }
   }
 }
-      `,
+              `.trimRight(),
             },
           ],
         },
@@ -402,21 +462,21 @@ function test(value: T): number {
     {
       // without existing cases
       code: `
-type T = 1 | 2
+type T = 1 | 2;
 
 function test(value: T): number {
   switch (value) {
   }
 }
-      `,
+      `.trimRight(),
       errors: [
         {
           messageId: 'switchIsNotExhaustive',
           suggestions: [
             {
               messageId: 'addMissingCases',
-              output: `
-type T = 1 | 2
+              output: noFormat`
+type T = 1 | 2;
 
 function test(value: T): number {
   switch (value) {
@@ -424,7 +484,7 @@ function test(value: T): number {
   case 2: { throw new Error('Not implemented yet: 2 case') }
   }
 }
-      `,
+              `.trimRight(),
             },
           ],
         },
diff --git a/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts b/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
index 690526edf63..ab10ba5f6d9 100644
--- a/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
+++ b/packages/eslint-plugin/tests/rules/triple-slash-reference.test.ts
@@ -12,93 +12,93 @@ ruleTester.run('triple-slash-reference', rule, {
   valid: [
     {
       code: `
-      // <reference path="foo" />
-      // <reference types="bar" />
-      // <reference lib="baz" />
-      import * as foo from "foo"
-      import * as bar from "bar"
-      import * as baz from "baz"
+        // <reference path="foo" />
+        // <reference types="bar" />
+        // <reference lib="baz" />
+        import * as foo from 'foo';
+        import * as bar from 'bar';
+        import * as baz from 'baz';
       `,
       options: [{ path: 'never', types: 'never', lib: 'never' }],
     },
     {
       code: `
-      // <reference path="foo" />
-      // <reference types="bar" />
-      // <reference lib="baz" />
-      import foo = require("foo")
-      import bar = require("bar")
-      import baz = require("baz")
+        // <reference path="foo" />
+        // <reference types="bar" />
+        // <reference lib="baz" />
+        import foo = require('foo');
+        import bar = require('bar');
+        import baz = require('baz');
       `,
       options: [{ path: 'never', types: 'never', lib: 'never' }],
     },
     {
       code: `
-      /// <reference path="foo" />
-      /// <reference types="bar" />
-      /// <reference lib="baz" />
-      import * as foo from "foo"
-      import * as bar from "bar"
-      import * as baz from "baz"
+        /// <reference path="foo" />
+        /// <reference types="bar" />
+        /// <reference lib="baz" />
+        import * as foo from 'foo';
+        import * as bar from 'bar';
+        import * as baz from 'baz';
       `,
       options: [{ path: 'always', types: 'always', lib: 'always' }],
     },
     {
       code: `
-      /// <reference path="foo" />
-      /// <reference types="bar" />
-      /// <reference lib="baz" />
-      import foo = require("foo")
-      import bar = require("bar")
-      import baz = require("baz")
+        /// <reference path="foo" />
+        /// <reference types="bar" />
+        /// <reference lib="baz" />
+        import foo = require('foo');
+        import bar = require('bar');
+        import baz = require('baz');
       `,
       options: [{ path: 'always', types: 'always', lib: 'always' }],
     },
     {
-      code: 'import * as foo from "foo"',
+      code: "import * as foo from 'foo';",
       options: [{ path: 'never' }],
     },
     {
-      code: 'import foo = require("foo");',
+      code: "import foo = require('foo');",
       options: [{ path: 'never' }],
     },
     {
-      code: 'import * as foo from "foo"',
+      code: "import * as foo from 'foo';",
       options: [{ types: 'never' }],
     },
     {
-      code: 'import foo = require("foo");',
+      code: "import foo = require('foo');",
       options: [{ types: 'never' }],
     },
     {
-      code: 'import * as foo from "foo"',
+      code: "import * as foo from 'foo';",
       options: [{ lib: 'never' }],
     },
     {
-      code: 'import foo = require("foo");',
+      code: "import foo = require('foo');",
       options: [{ lib: 'never' }],
     },
     {
-      code: 'import * as foo from "foo"',
+      code: "import * as foo from 'foo';",
       options: [{ types: 'prefer-import' }],
     },
     {
-      code: 'import foo = require("foo");',
+      code: "import foo = require('foo');",
       options: [{ types: 'prefer-import' }],
     },
     {
       code: `
-      /// <reference types="foo" />
-      import * as bar from "bar"
+        /// <reference types="foo" />
+        import * as bar from 'bar';
       `,
       options: [{ types: 'prefer-import' }],
     },
     {
       code: `
-      /*
-      /// <reference types="foo" />
-      */
-      import * as foo from "foo"
+        /*
+        /// <reference types="foo" />
+        */
+        import * as foo from 'foo';
       `,
       options: [{ path: 'never', types: 'never', lib: 'never' }],
     },
@@ -107,7 +107,7 @@ ruleTester.run('triple-slash-reference', rule, {
     {
       code: `
 /// <reference types="foo" />
-import * as foo from "foo"
+import * as foo from 'foo';
       `,
       options: [{ types: 'prefer-import' }],
       errors: [
@@ -121,7 +121,7 @@ import * as foo from "foo"
     {
       code: `
 /// <reference types="foo" />
-import foo = require("foo");
+import foo = require('foo');
       `,
       options: [{ types: 'prefer-import' }],
       errors: [
diff --git a/packages/eslint-plugin/tests/rules/type-annotation-spacing.test.ts b/packages/eslint-plugin/tests/rules/type-annotation-spacing.test.ts
index 6b0a3682578..de714cff43f 100644
--- a/packages/eslint-plugin/tests/rules/type-annotation-spacing.test.ts
+++ b/packages/eslint-plugin/tests/rules/type-annotation-spacing.test.ts
@@ -1,3 +1,8 @@
+/* eslint-disable eslint-comments/no-use */
+// this rule tests the spacing, which prettier will want to fix and break the tests
+/* eslint "@typescript-eslint/internal/plugin-test-formatting": ["error", { formatWithPrettier: false }] */
+/* eslint-enable eslint-comments/no-use */
+
 import { TSESLint } from '@typescript-eslint/experimental-utils';
 import { RuleTester } from '../RuleTester';
 import rule from '../../src/rules/type-annotation-spacing';
@@ -19,7 +24,7 @@ ruleTester.run('type-annotation-spacing', rule, {
 interface resolve {
     resolver: (() => PromiseLike<T>) | PromiseLike<T>;
 }
-        `,
+    `,
     'const foo = {} as Foo;',
     'let foo: string;',
     'function foo(): void {}',
@@ -28,63 +33,63 @@ interface resolve {
 class Foo {
     name: string;
 }
-        `,
+    `,
     `
 class Foo {
     constructor(message: string);
 }
-        `,
+    `,
     `
 class Foo {
     greet(): string { return "hello"; }
 }
-        `,
+    `,
     `
 class Foo {
     greet(name: string): string { return name; }
 }
-        `,
+    `,
     `
 interface Foo {
     name: string;
 }
-        `,
+    `,
     `
 interface Foo {
     greet(): string;
 }
-        `,
+    `,
     `
 interface Foo {
     greet(name: string): string;
 }
-        `,
+    `,
     `
 interface Foo {
     thing: { [key in string]: number };
 }
-        `,
+    `,
     `
 type Foo = {
     name: string;
 }
-        `,
+    `,
     `
 type Foo = {
     greet(): string;
 }
-        `,
+    `,
     `
 type Foo = {
     greet(name: string): string;
 }
-        `,
+    `,
     'type Foo = (name: string) => string;',
     `
 type Foo = {
     greet: (name: string) => string;
 }
-        `,
+    `,
     `
 const isString = (): x is string => {
 }
@@ -106,7 +111,7 @@ const isString = (): x is string => {
 class Foo {
     name: string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -114,7 +119,7 @@ class Foo {
 class Foo {
     constructor(message: string);
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -122,7 +127,7 @@ class Foo {
 class Foo {
     greet(): string { return "hello"; }
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -130,7 +135,7 @@ class Foo {
 class Foo {
     greet(name: string): string { return name; }
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -138,7 +143,7 @@ class Foo {
 interface Foo {
     name: string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -146,7 +151,7 @@ interface Foo {
 interface Foo {
     greet(): string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -154,7 +159,7 @@ interface Foo {
 interface Foo {
     greet(name: string): string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -162,7 +167,7 @@ interface Foo {
 type Foo = {
     name: string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -170,7 +175,7 @@ type Foo = {
 type Foo = {
     greet(): string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -178,7 +183,7 @@ type Foo = {
 type Foo = {
     greet(name: string): string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -190,7 +195,7 @@ type Foo = {
 type Foo = {
     greet: (name: string) => string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -210,7 +215,7 @@ type Foo = {
 class Foo {
     name: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -218,7 +223,7 @@ class Foo {
 class Foo {
     constructor(message: string);
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -226,7 +231,7 @@ class Foo {
 class Foo {
     greet(): string { return "hello"; }
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -234,7 +239,7 @@ class Foo {
 class Foo {
     greet(name: string): string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -242,7 +247,7 @@ class Foo {
 interface Foo {
     name: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -250,7 +255,7 @@ interface Foo {
 interface Foo {
     greet(): string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -258,7 +263,7 @@ interface Foo {
 interface Foo {
     greet(name: string): string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -266,7 +271,7 @@ interface Foo {
 type Foo = {
     name: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -274,7 +279,7 @@ type Foo = {
 type Foo = {
     greet(): string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -282,7 +287,7 @@ type Foo = {
 type Foo = {
     greet(name: string): string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -294,7 +299,7 @@ type Foo = {
 type Foo = {
     greet: (name: string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -314,7 +319,7 @@ type Foo = {
 class Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -322,7 +327,7 @@ class Foo {
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -330,7 +335,7 @@ class Foo {
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -338,7 +343,7 @@ class Foo {
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -346,7 +351,7 @@ class Foo {
 interface Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -354,7 +359,7 @@ interface Foo {
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -362,7 +367,7 @@ interface Foo {
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -370,7 +375,7 @@ interface Foo {
 type Foo = {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -378,7 +383,7 @@ type Foo = {
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -386,7 +391,7 @@ type Foo = {
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -398,7 +403,7 @@ type Foo = {
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -418,7 +423,7 @@ type Foo = {
 class Foo {
     name :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -426,7 +431,7 @@ class Foo {
 class Foo {
     constructor(message :string);
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -434,7 +439,7 @@ class Foo {
 class Foo {
     greet() :string { return "hello"; }
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -442,7 +447,7 @@ class Foo {
 class Foo {
     greet(name :string) :string { return name; }
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -450,7 +455,7 @@ class Foo {
 interface Foo {
     name :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -458,7 +463,7 @@ interface Foo {
 interface Foo {
     greet() :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -466,7 +471,7 @@ interface Foo {
 interface Foo {
     greet(name :string) :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -474,7 +479,7 @@ interface Foo {
 type Foo = {
     name :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -482,7 +487,7 @@ type Foo = {
 type Foo = {
     greet() :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -490,7 +495,7 @@ type Foo = {
 type Foo = {
     greet(name :string) :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -502,7 +507,7 @@ type Foo = {
 type Foo = {
     greet :(name :string) =>string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -522,7 +527,7 @@ type Foo = {
 class Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -530,7 +535,7 @@ class Foo {
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -538,7 +543,7 @@ class Foo {
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -546,7 +551,7 @@ class Foo {
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -554,7 +559,7 @@ class Foo {
 interface Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -562,7 +567,7 @@ interface Foo {
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -570,7 +575,7 @@ interface Foo {
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -578,7 +583,7 @@ interface Foo {
 type Foo = {
     name : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -586,7 +591,7 @@ type Foo = {
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -594,7 +599,7 @@ type Foo = {
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -606,7 +611,7 @@ type Foo = {
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -644,7 +649,7 @@ type Foo = {
 class Foo {
     name : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -658,7 +663,7 @@ class Foo {
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -672,7 +677,7 @@ class Foo {
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -686,7 +691,7 @@ class Foo {
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -700,7 +705,7 @@ class Foo {
 interface Foo {
     name : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -714,7 +719,7 @@ interface Foo {
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -728,7 +733,7 @@ interface Foo {
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -742,7 +747,7 @@ interface Foo {
 type Foo = {
     name : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -756,7 +761,7 @@ type Foo = {
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -770,7 +775,7 @@ type Foo = {
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -794,7 +799,7 @@ type Foo = {
 type Foo = {
     greet : (name : string)=>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -827,7 +832,7 @@ type Foo = {
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -868,7 +873,7 @@ type Foo = {
 type Foo = {
     greet : (name : string) =>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -890,7 +895,7 @@ type Foo = {
 interface Foo {
     thing: { [key in string]: number };
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -898,7 +903,7 @@ interface Foo {
 interface Foo {
     thing: { [key in string]: number };
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -906,7 +911,7 @@ interface Foo {
 interface Foo {
     thing : { [key in string] : number };
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -914,7 +919,7 @@ interface Foo {
 interface Foo {
     thing :{ [key in string] :number };
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -922,20 +927,20 @@ interface Foo {
 interface Foo {
     thing : { [key in string] : number };
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     `
 type Foo = {
     thing: { [key in string]: number };
 }
-        `,
+    `,
     {
       code: `
 type Foo = {
     thing: { [key in string]: number };
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -943,7 +948,7 @@ type Foo = {
 type Foo = {
     thing: { [key in string]: number };
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -951,7 +956,7 @@ type Foo = {
 type Foo = {
     thing : { [key in string] : number };
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -959,7 +964,7 @@ type Foo = {
 type Foo = {
     thing :{ [key in string] :number };
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -967,20 +972,20 @@ type Foo = {
 type Foo = {
     thing : { [key in string] : number };
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     `
 class Foo {
     greet: (name: string) => void = {}
 }
-        `,
+    `,
     {
       code: `
 class Foo {
     greet: (name: string) => void = {}
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -988,7 +993,7 @@ class Foo {
 class Foo {
     greet: (name: string)=> void = {}
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -996,7 +1001,7 @@ class Foo {
 class Foo {
     greet : (name : string) => void = {}
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -1004,7 +1009,7 @@ class Foo {
 class Foo {
     greet :(name :string) =>void = {}
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -1012,14 +1017,14 @@ class Foo {
 class Foo {
     greet : (name : string) => void = {}
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
       code: `
 interface Foo { a: string }
 type Bar = Record<keyof Foo, string>
-            `,
+      `,
       options: [
         {
           after: true,
@@ -1072,7 +1077,7 @@ type Bar = Record<keyof Foo, string>
 interface Foo {
   greet():string;
 }
-            `,
+      `,
       options: [
         {
           overrides: {
@@ -1092,7 +1097,7 @@ interface Foo {
 interface Foo {
   name:string;
 }
-             `,
+      `,
       options: [
         {
           before: true,
@@ -1219,12 +1224,12 @@ interface Foo {
 class Foo {
     name : string;
 }
-            `,
+      `,
       output: `
 class Foo {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1239,12 +1244,12 @@ class Foo {
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       output: `
 class Foo {
     constructor(message: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1259,12 +1264,12 @@ class Foo {
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       output: `
 class Foo {
     greet(): string { return "hello"; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1279,12 +1284,12 @@ class Foo {
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       output: `
 class Foo {
     greet(name: string): string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1305,12 +1310,12 @@ class Foo {
 interface Foo {
     name : string;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1325,12 +1330,12 @@ interface Foo {
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       output: `
 interface Foo {
     greet(): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1345,12 +1350,12 @@ interface Foo {
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       output: `
 interface Foo {
     greet(name: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1371,12 +1376,12 @@ interface Foo {
 type Foo = {
     name : string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1391,12 +1396,12 @@ type Foo = {
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     greet(): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1411,12 +1416,12 @@ type Foo = {
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     greet(name: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1467,12 +1472,12 @@ type Foo = {
 type Foo = {
     greet: (name : string) => string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     greet: (name: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1487,12 +1492,12 @@ type Foo = {
 type Foo = {
     greet: (name : string)=> string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     greet: (name: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1552,13 +1557,13 @@ type Foo = {
 class Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 class Foo {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1573,13 +1578,13 @@ class Foo {
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 class Foo {
     constructor(message: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1594,13 +1599,13 @@ class Foo {
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 class Foo {
     greet(): string { return "hello"; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1615,13 +1620,13 @@ class Foo {
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 class Foo {
     greet(name: string): string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1642,13 +1647,13 @@ class Foo {
 interface Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 interface Foo {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1663,13 +1668,13 @@ interface Foo {
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 interface Foo {
     greet(): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1684,13 +1689,13 @@ interface Foo {
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 interface Foo {
     greet(name: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1711,13 +1716,13 @@ interface Foo {
 type Foo = {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1732,13 +1737,13 @@ type Foo = {
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     greet(): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1753,13 +1758,13 @@ type Foo = {
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     greet(name: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1812,13 +1817,13 @@ type Foo = {
 type Foo = {
     greet: (name : string) => string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     greet: (name: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1833,13 +1838,13 @@ type Foo = {
 type Foo = {
     greet: (name : string)=> string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     greet: (name: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1899,13 +1904,13 @@ type Foo = {
 class Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 class Foo {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1920,13 +1925,13 @@ class Foo {
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 class Foo {
     constructor(message: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1941,13 +1946,13 @@ class Foo {
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 class Foo {
     greet(): string { return "hello"; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1962,13 +1967,13 @@ class Foo {
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 class Foo {
     greet(name: string): string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -1989,13 +1994,13 @@ class Foo {
 interface Foo {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 interface Foo {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2010,13 +2015,13 @@ interface Foo {
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 interface Foo {
     greet(): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2031,13 +2036,13 @@ interface Foo {
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 interface Foo {
     greet(name: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2058,13 +2063,13 @@ interface Foo {
 type Foo = {
     name : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     name: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2079,13 +2084,13 @@ type Foo = {
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     greet(): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2100,13 +2105,13 @@ type Foo = {
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     greet(name: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2159,13 +2164,13 @@ type Foo = {
 type Foo = {
     greet: (name : string) => string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     greet: (name: string)=> string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2186,13 +2191,13 @@ type Foo = {
 type Foo = {
     greet: (name : string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     greet: (name: string)=> string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -2264,13 +2269,13 @@ type Foo = {
 class Foo {
     name:string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 class Foo {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2291,13 +2296,13 @@ class Foo {
 class Foo {
     constructor(message:string);
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2318,13 +2323,13 @@ class Foo {
 class Foo {
     greet():string { return "hello"; }
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2345,13 +2350,13 @@ class Foo {
 class Foo {
     greet(name:string):string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2384,13 +2389,13 @@ class Foo {
 interface Foo {
     name:string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 interface Foo {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2411,13 +2416,13 @@ interface Foo {
 interface Foo {
     greet():string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2438,13 +2443,13 @@ interface Foo {
 interface Foo {
     greet(name:string):string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2477,13 +2482,13 @@ interface Foo {
 type Foo = {
     name:string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2504,13 +2509,13 @@ type Foo = {
 type Foo = {
     greet():string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2531,13 +2536,13 @@ type Foo = {
 type Foo = {
     greet(name:string):string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2602,13 +2607,13 @@ type Foo = {
 type Foo = {
     greet: (name: string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -2635,13 +2640,13 @@ type Foo = {
 type Foo = {
     greet : (name : string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -2713,13 +2718,13 @@ type Foo = {
 class Foo {
     name:string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 class Foo {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2740,13 +2745,13 @@ class Foo {
 class Foo {
     constructor(message:string);
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2767,13 +2772,13 @@ class Foo {
 class Foo {
     greet():string { return "hello"; }
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2794,13 +2799,13 @@ class Foo {
 class Foo {
     greet(name:string):string { return name; }
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2833,13 +2838,13 @@ class Foo {
 interface Foo {
     name:string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 interface Foo {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2860,13 +2865,13 @@ interface Foo {
 interface Foo {
     greet():string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2887,13 +2892,13 @@ interface Foo {
 interface Foo {
     greet(name:string):string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2926,13 +2931,13 @@ interface Foo {
 type Foo = {
     name:string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2953,13 +2958,13 @@ type Foo = {
 type Foo = {
     greet():string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -2980,13 +2985,13 @@ type Foo = {
 type Foo = {
     greet(name:string):string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3051,13 +3056,13 @@ type Foo = {
 type Foo = {
     greet: (name: string)=> string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -3084,13 +3089,13 @@ type Foo = {
 type Foo = {
     greet : (name : string)=> string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -3180,7 +3185,7 @@ type Foo = {
 class Foo {
     name:string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3192,7 +3197,7 @@ class Foo {
 class Foo {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3213,7 +3218,7 @@ class Foo {
 class Foo {
     constructor(message:string);
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3225,7 +3230,7 @@ class Foo {
 class Foo {
     constructor(message : string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3246,7 +3251,7 @@ class Foo {
 class Foo {
     greet():string { return "hello"; }
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3258,7 +3263,7 @@ class Foo {
 class Foo {
     greet() : string { return "hello"; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3279,7 +3284,7 @@ class Foo {
 class Foo {
     greet(name:string):string { return name; }
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3291,7 +3296,7 @@ class Foo {
 class Foo {
     greet(name : string) : string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3324,7 +3329,7 @@ class Foo {
 interface Foo {
     name:string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3336,7 +3341,7 @@ interface Foo {
 interface Foo {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3357,7 +3362,7 @@ interface Foo {
 interface Foo {
     greet():string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3369,7 +3374,7 @@ interface Foo {
 interface Foo {
     greet() : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3390,7 +3395,7 @@ interface Foo {
 interface Foo {
     greet(name:string):string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3402,7 +3407,7 @@ interface Foo {
 interface Foo {
     greet(name : string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3435,7 +3440,7 @@ interface Foo {
 type Foo = {
     name:string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3447,7 +3452,7 @@ type Foo = {
 type Foo = {
     name : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3468,7 +3473,7 @@ type Foo = {
 type Foo = {
     greet():string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3480,7 +3485,7 @@ type Foo = {
 type Foo = {
     greet() : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3501,7 +3506,7 @@ type Foo = {
 type Foo = {
     greet(name:string):string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3513,7 +3518,7 @@ type Foo = {
 type Foo = {
     greet(name : string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3571,7 +3576,7 @@ type Foo = {
 type Foo = {
     greet : (name:string)=>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3583,7 +3588,7 @@ type Foo = {
 type Foo = {
     greet : (name : string)=>string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3650,7 +3655,7 @@ type Foo = {
 type Foo = {
     greet : (name:string)=>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -3671,7 +3676,7 @@ type Foo = {
 type Foo = {
     greet : (name : string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceAfter',
@@ -3702,20 +3707,20 @@ type Foo = {
     // https://github.com/bradzacher/eslint-plugin-typescript/issues/152
     {
       code: `
-                class Some {
-                    a : {some: string, other: {more: number}};
-                    someMethod : (args : {some: string, other: {more: number}}) => void;
-                    doSomething(args : {some: string, other: {more: number}}) : void {}
-                }
-            `,
+        class Some {
+            a : {some: string, other: {more: number}};
+            someMethod : (args : {some: string, other: {more: number}}) => void;
+            doSomething(args : {some: string, other: {more: number}}) : void {}
+        }
+      `,
       options: [{ after: true, before: true }],
       output: `
-                class Some {
-                    a : {some : string, other : {more : number}};
-                    someMethod : (args : {some : string, other : {more : number}}) => void;
-                    doSomething(args : {some : string, other : {more : number}}) : void {}
-                }
-            `,
+        class Some {
+            a : {some : string, other : {more : number}};
+            someMethod : (args : {some : string, other : {more : number}}) => void;
+            doSomething(args : {some : string, other : {more : number}}) : void {}
+        }
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -3723,7 +3728,7 @@ type Foo = {
             type: ':',
           },
           line: 3,
-          column: 30,
+          column: 22,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3731,7 +3736,7 @@ type Foo = {
             type: ':',
           },
           line: 3,
-          column: 45,
+          column: 37,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3739,7 +3744,7 @@ type Foo = {
             type: ':',
           },
           line: 3,
-          column: 52,
+          column: 44,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3747,7 +3752,7 @@ type Foo = {
             type: ':',
           },
           line: 4,
-          column: 47,
+          column: 39,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3755,7 +3760,7 @@ type Foo = {
             type: ':',
           },
           line: 4,
-          column: 62,
+          column: 54,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3763,7 +3768,7 @@ type Foo = {
             type: ':',
           },
           line: 4,
-          column: 69,
+          column: 61,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3771,7 +3776,7 @@ type Foo = {
             type: ':',
           },
           line: 5,
-          column: 45,
+          column: 37,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3779,7 +3784,7 @@ type Foo = {
             type: ':',
           },
           line: 5,
-          column: 60,
+          column: 52,
         },
         {
           messageId: 'expectedSpaceBefore',
@@ -3787,7 +3792,7 @@ type Foo = {
             type: ':',
           },
           line: 5,
-          column: 67,
+          column: 59,
         },
       ],
     },
@@ -3804,54 +3809,54 @@ ruleTester.run('type-annotation-spacing', rule, {
 interface resolve {
     resolver?: (() => PromiseLike<T>) | PromiseLike<T>;
 }
-        `,
+    `,
     'function foo(a?: string) {}',
     `
 class Foo {
     name?: string;
 }
-        `,
+    `,
     `
 class Foo {
     constructor(message?: string);
 }
-        `,
+    `,
     `
 class Foo {
     greet(name?: string): string { return name; }
 }
-        `,
+    `,
     `
 interface Foo {
     name?: string;
 }
-        `,
+    `,
     `
 interface Foo {
     greet(name?: string): string;
 }
-        `,
+    `,
     `
 interface Foo {
     thing?: { [key in string]?: number };
 }
-        `,
+    `,
     `
 type Foo = {
     name?: string;
 }
-        `,
+    `,
     `
 type Foo = {
     greet(name?: string): string;
 }
-        `,
+    `,
     'type Foo = (name?: string) => string;',
     `
 type Foo = {
     greet?: (name?: string) => string;
 }
-        `,
+    `,
     {
       code: 'function foo(a?: string) {}',
       options: [{ after: true }],
@@ -3861,7 +3866,7 @@ type Foo = {
 class Foo {
     name?: string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3869,7 +3874,7 @@ class Foo {
 class Foo {
     constructor(message?: string);
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3877,7 +3882,7 @@ class Foo {
 class Foo {
     greet(name?: string): string { return name; }
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3885,7 +3890,7 @@ class Foo {
 interface Foo {
     name?: string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3893,7 +3898,7 @@ interface Foo {
 interface Foo {
     greet(name?: string): string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3901,7 +3906,7 @@ interface Foo {
 type Foo = {
     name?: string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3909,7 +3914,7 @@ type Foo = {
 type Foo = {
     greet(name?: string): string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3921,7 +3926,7 @@ type Foo = {
 type Foo = {
     greet?: (name?: string) => string;
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -3933,7 +3938,7 @@ type Foo = {
 class Foo {
     name?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -3941,7 +3946,7 @@ class Foo {
 class Foo {
     constructor(message?: string);
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -3949,7 +3954,7 @@ class Foo {
 class Foo {
     greet(name?: string): string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -3957,7 +3962,7 @@ class Foo {
 interface Foo {
     name?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -3965,7 +3970,7 @@ interface Foo {
 interface Foo {
     greet(name?: string): string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -3973,7 +3978,7 @@ interface Foo {
 type Foo = {
     name?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -3981,7 +3986,7 @@ type Foo = {
 type Foo = {
     greet(name?: string): string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -3993,7 +3998,7 @@ type Foo = {
 type Foo = {
     greet?: (name?: string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -4005,7 +4010,7 @@ type Foo = {
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4013,7 +4018,7 @@ class Foo {
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4021,7 +4026,7 @@ class Foo {
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4029,7 +4034,7 @@ class Foo {
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4037,7 +4042,7 @@ interface Foo {
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4045,7 +4050,7 @@ interface Foo {
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4053,7 +4058,7 @@ type Foo = {
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4065,7 +4070,7 @@ type Foo = {
 type Foo = {
     greet ?: (name : string) => string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4077,7 +4082,7 @@ type Foo = {
 class Foo {
     name ?:string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4085,7 +4090,7 @@ class Foo {
 class Foo {
     constructor(message ?:string);
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4093,7 +4098,7 @@ class Foo {
 class Foo {
     greet(name ?:string) :string { return name; }
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4101,7 +4106,7 @@ class Foo {
 interface Foo {
     name ?:string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4109,7 +4114,7 @@ interface Foo {
 interface Foo {
     greet(name ?:string) :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4117,7 +4122,7 @@ interface Foo {
 type Foo = {
     name ?:string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4125,7 +4130,7 @@ type Foo = {
 type Foo = {
     greet(name ?:string) :string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4137,7 +4142,7 @@ type Foo = {
 type Foo = {
     greet :(name ?:string) =>string;
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4149,7 +4154,7 @@ type Foo = {
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4157,7 +4162,7 @@ class Foo {
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4165,7 +4170,7 @@ class Foo {
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4173,7 +4178,7 @@ class Foo {
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4181,7 +4186,7 @@ interface Foo {
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4189,7 +4194,7 @@ interface Foo {
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4197,7 +4202,7 @@ type Foo = {
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4209,7 +4214,7 @@ type Foo = {
 type Foo = {
     greet : (name ?: string) => string;
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
@@ -4227,7 +4232,7 @@ type Foo = {
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4241,7 +4246,7 @@ class Foo {
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4255,7 +4260,7 @@ class Foo {
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4269,7 +4274,7 @@ class Foo {
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4283,7 +4288,7 @@ interface Foo {
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4297,7 +4302,7 @@ interface Foo {
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4311,7 +4316,7 @@ type Foo = {
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4335,7 +4340,7 @@ type Foo = {
 type Foo = {
     greet ?: (name ?: string)=>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4368,7 +4373,7 @@ type Foo = {
 type Foo = {
     greet ?: (name ?: string) => string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4409,7 +4414,7 @@ type Foo = {
 type Foo = {
     greet : (name ?: string) =>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -4431,7 +4436,7 @@ type Foo = {
 interface Foo {
     thing?: { [key in string]?: number };
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -4439,7 +4444,7 @@ interface Foo {
 interface Foo {
     thing?: { [key in string]?: number };
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -4447,7 +4452,7 @@ interface Foo {
 interface Foo {
     thing ?: { [key in string] ?: number };
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4455,7 +4460,7 @@ interface Foo {
 interface Foo {
     thing ?:{ [key in string] ?:number };
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4463,20 +4468,20 @@ interface Foo {
 interface Foo {
     thing ?: { [key in string] ?: number };
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     `
 type Foo = {
     thing?: { [key in string]?: number };
 }
-        `,
+    `,
     {
       code: `
 type Foo = {
     thing?: { [key in string]?: number };
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -4484,7 +4489,7 @@ type Foo = {
 type Foo = {
     thing?: { [key in string]?: number };
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -4492,7 +4497,7 @@ type Foo = {
 type Foo = {
     thing ?: { [key in string] ?: number };
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4500,7 +4505,7 @@ type Foo = {
 type Foo = {
     thing ?:{ [key in string] ?:number };
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4508,20 +4513,20 @@ type Foo = {
 type Foo = {
     thing ?: { [key in string] ?: number };
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     `
 class Foo {
     greet: (name?: string) => void = {}
 }
-        `,
+    `,
     {
       code: `
 class Foo {
     greet: (name?: string) => void = {}
 }
-            `,
+      `,
       options: [{ after: true }],
     },
     {
@@ -4529,7 +4534,7 @@ class Foo {
 class Foo {
     greet: (name?: string)=> void = {}
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
     },
     {
@@ -4537,7 +4542,7 @@ class Foo {
 class Foo {
     greet : (name ?: string) => void = {}
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
     },
     {
@@ -4545,7 +4550,7 @@ class Foo {
 class Foo {
     greet :(name ?:string) =>void = {}
 }
-            `,
+      `,
       options: [{ after: false, before: true }],
     },
     {
@@ -4553,14 +4558,14 @@ class Foo {
 class Foo {
     greet : (name ?: string) => void = {}
 }
-            `,
+      `,
       options: [{ before: true }],
     },
     {
       code: `
 interface Foo { a?: string }
 type Bar = Record<keyof Foo, string>
-            `,
+      `,
       options: [
         {
           after: true,
@@ -4593,12 +4598,12 @@ type Bar = Record<keyof Foo, string>
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       output: `
 class Foo {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4613,12 +4618,12 @@ class Foo {
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       output: `
 class Foo {
     constructor(message?: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4633,12 +4638,12 @@ class Foo {
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       output: `
 class Foo {
     greet(name?: string): string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4659,12 +4664,12 @@ class Foo {
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       output: `
 interface Foo {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4679,12 +4684,12 @@ interface Foo {
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       output: `
 interface Foo {
     greet(name?: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4705,12 +4710,12 @@ interface Foo {
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4725,12 +4730,12 @@ type Foo = {
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     greet(name?: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4781,12 +4786,12 @@ type Foo = {
 type Foo = {
     greet: (name ?: string) => string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     greet: (name?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4801,12 +4806,12 @@ type Foo = {
 type Foo = {
     greet: (name ?: string)=> string;
 }
-            `,
+      `,
       output: `
 type Foo = {
     greet: (name?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4840,13 +4845,13 @@ type Foo = {
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 class Foo {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4861,13 +4866,13 @@ class Foo {
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 class Foo {
     constructor(message?: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4882,13 +4887,13 @@ class Foo {
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 class Foo {
     greet(name?: string): string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4909,13 +4914,13 @@ class Foo {
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 interface Foo {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4930,13 +4935,13 @@ interface Foo {
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 interface Foo {
     greet(name?: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4957,13 +4962,13 @@ interface Foo {
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -4978,13 +4983,13 @@ type Foo = {
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     greet(name?: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5037,13 +5042,13 @@ type Foo = {
 type Foo = {
     greet: (name ?: string) => string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     greet: (name?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5058,13 +5063,13 @@ type Foo = {
 type Foo = {
     greet: (name ?: string)=> string;
 }
-            `,
+      `,
       options: [{ after: true }],
       output: `
 type Foo = {
     greet: (name?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5098,13 +5103,13 @@ type Foo = {
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 class Foo {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5119,13 +5124,13 @@ class Foo {
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 class Foo {
     constructor(message?: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5140,13 +5145,13 @@ class Foo {
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 class Foo {
     greet(name?: string): string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5167,13 +5172,13 @@ class Foo {
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 interface Foo {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5188,13 +5193,13 @@ interface Foo {
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 interface Foo {
     greet(name?: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5215,13 +5220,13 @@ interface Foo {
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     name?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5236,13 +5241,13 @@ type Foo = {
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     greet(name?: string): string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5295,13 +5300,13 @@ type Foo = {
 type Foo = {
     greet: (name ?: string) => string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     greet: (name?: string)=> string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5322,13 +5327,13 @@ type Foo = {
 type Foo = {
     greet: (name ?: string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: false }],
       output: `
 type Foo = {
     greet: (name?: string)=> string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'unexpectedSpaceBefore',
@@ -5362,13 +5367,13 @@ type Foo = {
 class Foo {
     name?:string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5389,13 +5394,13 @@ class Foo {
 class Foo {
     constructor(message?:string);
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5416,13 +5421,13 @@ class Foo {
 class Foo {
     greet(name?:string):string { return name; }
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5455,13 +5460,13 @@ class Foo {
 interface Foo {
     name?:string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5482,13 +5487,13 @@ interface Foo {
 interface Foo {
     greet(name?:string):string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5521,13 +5526,13 @@ interface Foo {
 type Foo = {
     name?:string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5548,13 +5553,13 @@ type Foo = {
 type Foo = {
     greet(name?:string):string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5619,13 +5624,13 @@ type Foo = {
 type Foo = {
     greet?: (name?: string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     greet ?: (name ?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5652,13 +5657,13 @@ type Foo = {
 type Foo = {
     greet ?: (name ?: string)=> string;
 }
-            `,
+      `,
       options: [{ after: true, before: true }],
       output: `
 type Foo = {
     greet ?: (name ?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5692,13 +5697,13 @@ type Foo = {
 class Foo {
     name?:string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5719,13 +5724,13 @@ class Foo {
 class Foo {
     constructor(message?:string);
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5746,13 +5751,13 @@ class Foo {
 class Foo {
     greet(name?:string):string { return name; }
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5785,13 +5790,13 @@ class Foo {
 interface Foo {
     name?:string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5812,13 +5817,13 @@ interface Foo {
 interface Foo {
     greet(name?:string):string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5851,13 +5856,13 @@ interface Foo {
 type Foo = {
     name?:string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5878,13 +5883,13 @@ type Foo = {
 type Foo = {
     greet(name?:string):string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5949,13 +5954,13 @@ type Foo = {
 type Foo = {
     greet?: (name?: string)=> string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     greet ?: (name ?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -5982,13 +5987,13 @@ type Foo = {
 type Foo = {
     greet ?: (name ?: string)=> string;
 }
-            `,
+      `,
       options: [{ before: true }],
       output: `
 type Foo = {
     greet ?: (name ?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6028,7 +6033,7 @@ type Foo = {
 class Foo {
     name?:string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6040,7 +6045,7 @@ class Foo {
 class Foo {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6061,7 +6066,7 @@ class Foo {
 class Foo {
     constructor(message?:string);
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6073,7 +6078,7 @@ class Foo {
 class Foo {
     constructor(message ?: string);
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6094,7 +6099,7 @@ class Foo {
 class Foo {
     greet(name?:string):string { return name; }
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6106,7 +6111,7 @@ class Foo {
 class Foo {
     greet(name ?: string) : string { return name; }
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6139,7 +6144,7 @@ class Foo {
 interface Foo {
     name?:string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6151,7 +6156,7 @@ interface Foo {
 interface Foo {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6172,7 +6177,7 @@ interface Foo {
 interface Foo {
     greet(name?:string):string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6184,7 +6189,7 @@ interface Foo {
 interface Foo {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6217,7 +6222,7 @@ interface Foo {
 type Foo = {
     name?:string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6229,7 +6234,7 @@ type Foo = {
 type Foo = {
     name ?: string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6250,7 +6255,7 @@ type Foo = {
 type Foo = {
     greet(name?:string):string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6262,7 +6267,7 @@ type Foo = {
 type Foo = {
     greet(name ?: string) : string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6320,7 +6325,7 @@ type Foo = {
 type Foo = {
     greet ?: (name?:string)=>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6332,7 +6337,7 @@ type Foo = {
 type Foo = {
     greet ?: (name ?: string)=>string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
@@ -6399,7 +6404,7 @@ type Foo = {
 type Foo = {
     greet ?: (name?:string)=>string;
 }
-            `,
+      `,
       options: [
         {
           before: false,
@@ -6420,7 +6425,7 @@ type Foo = {
 type Foo = {
     greet ?: (name ?: string) => string;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'expectedSpaceBefore',
diff --git a/packages/eslint-plugin/tests/rules/typedef.test.ts b/packages/eslint-plugin/tests/rules/typedef.test.ts
index bbb1a49c018..d6b37c811ed 100644
--- a/packages/eslint-plugin/tests/rules/typedef.test.ts
+++ b/packages/eslint-plugin/tests/rules/typedef.test.ts
@@ -15,7 +15,7 @@ ruleTester.run('typedef', rule, {
   valid: [
     // Array destructuring
     {
-      code: `const [a]: [number] = [1]`,
+      code: 'const [a]: [number] = [1];',
       options: [
         {
           arrayDestructuring: true,
@@ -23,7 +23,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const [a, b]: [number, number] = [1, 2]`,
+      code: 'const [a, b]: [number, number] = [1, 2];',
       options: [
         {
           arrayDestructuring: true,
@@ -31,7 +31,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const [a] = 1;`,
+      code: 'const [a] = 1;',
       options: [
         {
           arrayDestructuring: false,
@@ -39,7 +39,10 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `for (const [key, val] of new Map([['key', 1]])) {}`,
+      code: `
+        for (const [key, val] of new Map([['key', 1]])) {
+        }
+      `,
       options: [
         {
           arrayDestructuring: true,
@@ -47,7 +50,10 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `for (const [[key]] of [[['key']]]) {}`,
+      code: `
+        for (const [[key]] of [[['key']]]) {
+        }
+      `,
       options: [
         {
           arrayDestructuring: true,
@@ -55,20 +61,25 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `for (const [[{ key }]] of [[[{ key: 'value' }]]]) {}`,
+      code: `
+        for (const [[{ key }]] of [[[{ key: 'value' }]]]) {
+        }
+      `,
       options: [
         {
           arrayDestructuring: true,
         },
       ],
     },
-    `let a: number;
-    [a] = [1];`,
+    `
+      let a: number;
+      [a] = [1];
+    `,
     // Arrow parameters
-    `((a: number): void => {})()`,
-    `((a: string, b: string): void => {})()`,
+    '((a: number): void => {})();',
+    '((a: string, b: string): void => {})();',
     {
-      code: `((a: number): void => { })()`,
+      code: '((a: number): void => {})();',
       options: [
         {
           arrowParameter: false,
@@ -76,7 +87,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `((a: string, b: string): void => { })()`,
+      code: '((a: string, b: string): void => {})();',
       options: [
         {
           arrowParameter: false,
@@ -84,16 +95,22 @@ ruleTester.run('typedef', rule, {
       ],
     },
     // Member variable declarations
-    `class Test {
-      state: number;
-    }`,
-    `class Test {
-      state: number = 1;
-    }`,
+    `
+      class Test {
+        state: number;
+      }
+    `,
+    `
+      class Test {
+        state: number = 1;
+      }
+    `,
     {
-      code: `class Test {
-        state = 1;
-      }`,
+      code: `
+        class Test {
+          state = 1;
+        }
+      `,
       options: [
         {
           memberVariableDeclaration: false,
@@ -102,7 +119,7 @@ ruleTester.run('typedef', rule, {
     },
     // Object destructuring
     {
-      code: `const { a }: { a: number } = { a: 1 }`,
+      code: 'const { a }: { a: number } = { a: 1 };',
       options: [
         {
           objectDestructuring: true,
@@ -110,7 +127,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const { a, b }: { [i: string]: number } = { a: 1, b: 2 }`,
+      code: 'const { a, b }: { [i: string]: number } = { a: 1, b: 2 };',
       options: [
         {
           objectDestructuring: true,
@@ -118,7 +135,14 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `for (const {p1: {p2: { p3 }}} of [{p1: {p2: {p3: 'value'}}}]) {}`,
+      code: `
+        for (const {
+          p1: {
+            p2: { p3 },
+          },
+        } of [{ p1: { p2: { p3: 'value' } } }]) {
+        }
+      `,
       options: [
         {
           objectDestructuring: true,
@@ -126,7 +150,16 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `for (const {p1: {p2: { p3: [key] }}} of [{p1: {p2: {p3: ['value']}}}]) {}`,
+      code: `
+        for (const {
+          p1: {
+            p2: {
+              p3: [key],
+            },
+          },
+        } of [{ p1: { p2: { p3: ['value'] } } }]) {
+        }
+      `,
       options: [
         {
           objectDestructuring: true,
@@ -134,7 +167,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const { a } = { a: 1 };`,
+      code: 'const { a } = { a: 1 };',
       options: [
         {
           objectDestructuring: false,
@@ -142,7 +175,10 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `for (const { key, val } of [{ key: 'key', val: 1 }]) {}`,
+      code: `
+        for (const { key, val } of [{ key: 'key', val: 1 }]) {
+        }
+      `,
       options: [
         {
           objectDestructuring: true,
@@ -150,50 +186,76 @@ ruleTester.run('typedef', rule, {
       ],
     },
     // Function parameters
-    `function receivesNumber(a: number): void { }`,
-    `function receivesStrings(a: string, b: string): void { }`,
-    `function receivesNumber([a]: [number]): void { }`,
-    `function receivesNumbers([a, b]: number[]): void { }`,
-    `function receivesString({ a }: { a: string }): void { }`,
-    `function receivesStrings({ a, b }: { [i: string ]: string }): void { }`,
-    `function receivesNumber(a: number = 123): void { }`,
+    'function receivesNumber(a: number): void {}',
+    'function receivesStrings(a: string, b: string): void {}',
+    'function receivesNumber([a]: [number]): void {}',
+    'function receivesNumbers([a, b]: number[]): void {}',
+    'function receivesString({ a }: { a: string }): void {}',
+    'function receivesStrings({ a, b }: { [i: string]: string }): void {}',
+    'function receivesNumber(a: number = 123): void {}',
     // Constructor parameters
-    `class Test {
-      constructor() {}
-    }`,
-    `class Test {
-      constructor(param: string) {}
-    }`,
-    `class Test {
-      constructor(param: string = 'something') {}
-    }`,
-    `class Test {
-      constructor(private param: string = 'something') {}
-    }`,
+    `
+      class Test {
+        constructor() {}
+      }
+    `,
+    `
+      class Test {
+        constructor(param: string) {}
+      }
+    `,
+    `
+      class Test {
+        constructor(param: string = 'something') {}
+      }
+    `,
+    `
+      class Test {
+        constructor(private param: string = 'something') {}
+      }
+    `,
     // Method parameters
-    `class Test {
-      public method(x: number): number { return x; }
-    }`,
-    `class Test {
-      public method(x: number = 123): number { return x; }
-    }`,
+    `
+      class Test {
+        public method(x: number): number {
+          return x;
+        }
+      }
+    `,
+    `
+      class Test {
+        public method(x: number = 123): number {
+          return x;
+        }
+      }
+    `,
     // Property declarations
-    `type Test = {
-       member: number;
-     };`,
-    `type Test = {
-       [i: string]: number;
-     };`,
-    `interface Test {
-      member: string;
-     };`,
-    `interface Test {
-      [i: number]: string;
-     };`,
-    {
-      code: `type Test = {
-        member;
-      };`,
+    `
+      type Test = {
+        member: number;
+      };
+    `,
+    `
+      type Test = {
+        [i: string]: number;
+      };
+    `,
+    `
+      interface Test {
+        member: string;
+      }
+    `,
+    `
+      interface Test {
+        [i: number]: string;
+      }
+    `,
+    {
+      code: `
+        type Test = {
+          member;
+        };
+      `,
       options: [
         {
           propertyDeclaration: false,
@@ -201,9 +263,12 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `type Test = {
-        [i: string];
-      };`,
+      code: `
+        type Test = {
+          // prettier-ignore
+          [i: string];
+        };
+      `,
       options: [
         {
           propertyDeclaration: false,
@@ -212,7 +277,7 @@ ruleTester.run('typedef', rule, {
     },
     // Variable declarations
     {
-      code: `const x: string = "";`,
+      code: "const x: string = '';",
       options: [
         {
           variableDeclaration: true,
@@ -220,7 +285,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `let x: string = "";`,
+      code: "let x: string = '';",
       options: [
         {
           variableDeclaration: true,
@@ -228,7 +293,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `let x: string;`,
+      code: 'let x: string;',
       options: [
         {
           variableDeclaration: true,
@@ -236,7 +301,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const a = 1;`,
+      code: 'const a = 1;',
       options: [
         {
           variableDeclaration: false,
@@ -244,7 +309,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `let a;`,
+      code: 'let a;',
       options: [
         {
           variableDeclaration: false,
@@ -252,7 +317,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `let a = 1;`,
+      code: 'let a = 1;',
       options: [
         {
           variableDeclaration: false,
@@ -260,7 +325,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const [a, b] = [1, 2];`,
+      code: 'const [a, b] = [1, 2];',
       options: [
         {
           objectDestructuring: false,
@@ -269,7 +334,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const { a, b } = { a: '', b: '' };`,
+      code: "const { a, b } = { a: '', b: '' };",
       options: [
         {
           objectDestructuring: false,
@@ -279,7 +344,10 @@ ruleTester.run('typedef', rule, {
     },
     // Contexts where TypeScript doesn't allow annotations
     {
-      code: `for (x of [1, 2, 3]) { }`,
+      code: `
+        for (x of [1, 2, 3]) {
+        }
+      `,
       options: [
         {
           variableDeclaration: true,
@@ -287,7 +355,10 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `for (const x in {}) { }`,
+      code: `
+        for (const x in {}) {
+        }
+      `,
       options: [
         {
           variableDeclaration: true,
@@ -295,7 +366,10 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `try { } catch (e) { }`,
+      code: `
+        try {
+        } catch (e) {}
+      `,
       options: [
         {
           variableDeclaration: true,
@@ -304,7 +378,7 @@ ruleTester.run('typedef', rule, {
     },
     // variable declaration ignore function
     {
-      code: `const foo = function(): void {};`,
+      code: 'const foo = function(): void {};',
       options: [
         {
           variableDeclaration: true,
@@ -313,7 +387,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const foo = (): void => {};`,
+      code: 'const foo = (): void => {};',
       options: [
         {
           variableDeclaration: true,
@@ -322,7 +396,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const foo: () => void = (): void => {};`,
+      code: 'const foo: () => void = (): void => {};',
       options: [
         {
           variableDeclaration: true,
@@ -331,7 +405,7 @@ ruleTester.run('typedef', rule, {
       ],
     },
     {
-      code: `const foo: () => void = function (): void {};`,
+      code: 'const foo: () => void = function(): void {};',
       options: [
         {
           variableDeclaration: true,
@@ -343,7 +417,7 @@ ruleTester.run('typedef', rule, {
       code: `
 class Foo {
   a = (): void => {};
-  b = function (): void {};
+  b = function(): void {};
 }
       `,
       options: [
@@ -357,7 +431,7 @@ class Foo {
   invalid: [
     // Array destructuring
     {
-      code: `const [a] = [1]`,
+      code: 'const [a] = [1];',
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -370,7 +444,7 @@ class Foo {
       ],
     },
     {
-      code: `const [a, b] = [1, 2]`,
+      code: 'const [a, b] = [1, 2];',
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -384,7 +458,7 @@ class Foo {
     },
     // Object destructuring
     {
-      code: `const { a } = { a: 1 }`,
+      code: 'const { a } = { a: 1 };',
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -397,7 +471,7 @@ class Foo {
       ],
     },
     {
-      code: `const { a, b } = { a: 1, b: 2 }`,
+      code: 'const { a, b } = { a: 1, b: 2 };',
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -411,7 +485,7 @@ class Foo {
     },
     // Arrow parameters
     {
-      code: `const receivesNumber = (a): void => { }`,
+      code: 'const receivesNumber = (a): void => {};',
       errors: [
         {
           data: { name: 'a' },
@@ -420,7 +494,7 @@ class Foo {
       ],
     },
     {
-      code: `const receivesStrings = (a, b): void => { }`,
+      code: 'const receivesStrings = (a, b): void => {};',
       errors: [
         {
           data: { name: 'a' },
@@ -434,9 +508,11 @@ class Foo {
     },
     // Member variable declarations
     {
-      code: `class Test {
-        state = 1;
-      }`,
+      code: `
+        class Test {
+          state = 1;
+        }
+      `,
       errors: [
         {
           data: { name: 'state' },
@@ -445,9 +521,11 @@ class Foo {
       ],
     },
     {
-      code: `class Test {
-        ["state"] = 1;
-      }`,
+      code: `
+        class Test {
+          ['state'] = 1;
+        }
+      `,
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -456,7 +534,7 @@ class Foo {
     },
     // Function parameters
     {
-      code: `function receivesNumber(a): void { }`,
+      code: 'function receivesNumber(a): void {}',
       errors: [
         {
           data: { name: 'a' },
@@ -465,7 +543,7 @@ class Foo {
       ],
     },
     {
-      code: `function receivesStrings(a, b): void { }`,
+      code: 'function receivesStrings(a, b): void {}',
       errors: [
         {
           data: { name: 'a' },
@@ -478,7 +556,7 @@ class Foo {
       ],
     },
     {
-      code: `function receivesNumber([a]): void { }`,
+      code: 'function receivesNumber([a]): void {}',
       errors: [
         {
           column: 25,
@@ -487,7 +565,7 @@ class Foo {
       ],
     },
     {
-      code: `function receivesNumbers([a, b]): void { }`,
+      code: 'function receivesNumbers([a, b]): void {}',
       errors: [
         {
           column: 26,
@@ -496,7 +574,7 @@ class Foo {
       ],
     },
     {
-      code: `function receivesString({ a }): void { }`,
+      code: 'function receivesString({ a }): void {}',
       errors: [
         {
           column: 25,
@@ -505,7 +583,7 @@ class Foo {
       ],
     },
     {
-      code: `function receivesStrings({ a, b }): void { }`,
+      code: 'function receivesStrings({ a, b }): void {}',
       errors: [
         {
           column: 26,
@@ -515,77 +593,95 @@ class Foo {
     },
     // Constructor parameters
     {
-      code: `class Test {
-        constructor(param) {}
-      }`,
+      code: `
+        class Test {
+          constructor(param) {}
+        }
+      `,
       errors: [
         {
-          column: 21,
+          column: 23,
           messageId: 'expectedTypedefNamed',
         },
       ],
     },
     {
-      code: `class Test {
-        constructor(param = 'something') {}
-      }`,
+      code: `
+        class Test {
+          constructor(param = 'something') {}
+        }
+      `,
       errors: [
         {
-          column: 21,
+          column: 23,
           messageId: 'expectedTypedef',
         },
       ],
     },
     {
-      code: `class Test {
-        constructor(private param = 'something') {}
-      }`,
+      code: `
+        class Test {
+          constructor(private param = 'something') {}
+        }
+      `,
       errors: [
         {
-          column: 21,
+          column: 23,
           messageId: 'expectedTypedef',
         },
       ],
     },
     // Method parameters
     {
-      code: `class Test {
-        public method(x): number { return x; }
-      }`,
+      code: `
+        class Test {
+          public method(x): number {
+            return x;
+          }
+        }
+      `,
       errors: [
         {
-          column: 23,
+          column: 25,
           messageId: 'expectedTypedefNamed',
         },
       ],
     },
     {
-      code: `class Test {
-        public method(x = 123): number { return x; }
-      }`,
+      code: `
+        class Test {
+          public method(x = 123): number {
+            return x;
+          }
+        }
+      `,
       errors: [
         {
-          column: 23,
+          column: 25,
           messageId: 'expectedTypedef',
         },
       ],
     },
     {
-      code: `class Test {
-        public constructor(public x) { }
-      }`,
+      code: `
+        class Test {
+          public constructor(public x) {}
+        }
+      `,
       errors: [
         {
-          column: 28,
+          column: 30,
           messageId: 'expectedTypedef',
         },
       ],
     },
     // Property declarations
     {
-      code: `type Test = {
-        member;
-      };`,
+      code: `
+        type Test = {
+          member;
+        };
+      `,
       errors: [
         {
           data: { name: 'member' },
@@ -594,9 +690,12 @@ class Foo {
       ],
     },
     {
-      code: `type Test = {
-        [i: string];
-      };`,
+      code: `
+        type Test = {
+          // prettier-ignore
+          [i: string];
+        };
+      `,
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -604,9 +703,11 @@ class Foo {
       ],
     },
     {
-      code: `interface Test {
-        member;
-      };`,
+      code: `
+        interface Test {
+          member;
+        }
+      `,
       errors: [
         {
           data: { name: 'member' },
@@ -615,9 +716,12 @@ class Foo {
       ],
     },
     {
-      code: `interface Test {
-        [i: string];
-      };`,
+      code: `
+        interface Test {
+          // prettier-ignore
+          [i: string];
+        }
+      `,
       errors: [
         {
           messageId: 'expectedTypedef',
@@ -626,7 +730,7 @@ class Foo {
     },
     // Variable declarations
     {
-      code: `const a = 1;`,
+      code: 'const a = 1;',
       errors: [
         {
           data: { name: 'a' },
@@ -640,7 +744,11 @@ class Foo {
       ],
     },
     {
-      code: `const a = 1, b: number = 2, c = 3;`,
+      code: `
+        const a = 1,
+          b: number = 2,
+          c = 3;
+      `,
       errors: [
         {
           data: { name: 'a' },
@@ -658,7 +766,7 @@ class Foo {
       ],
     },
     {
-      code: `let a;`,
+      code: 'let a;',
       errors: [
         {
           data: { name: 'a' },
@@ -672,7 +780,7 @@ class Foo {
       ],
     },
     {
-      code: `let a = 1;`,
+      code: 'let a = 1;',
       errors: [
         {
           data: { name: 'a' },
@@ -686,7 +794,11 @@ class Foo {
       ],
     },
     {
-      code: `let a = 1, b: number, c = 2;`,
+      code: `
+        let a = 1,
+          b: number,
+          c = 2;
+      `,
       errors: [
         {
           data: { name: 'a' },
@@ -704,7 +816,7 @@ class Foo {
       ],
     },
     {
-      code: `const foo = 'foo'`,
+      code: "const foo = 'foo';",
       errors: [
         {
           messageId: 'expectedTypedefNamed',
@@ -719,7 +831,7 @@ class Foo {
       ],
     },
     {
-      code: `const foo = function(): void {};`,
+      code: 'const foo = function(): void {};',
       errors: [
         {
           messageId: 'expectedTypedefNamed',
@@ -734,7 +846,7 @@ class Foo {
       ],
     },
     {
-      code: `const foo = (): void => {};`,
+      code: 'const foo = (): void => {};',
       errors: [
         {
           messageId: 'expectedTypedefNamed',
@@ -752,7 +864,7 @@ class Foo {
       code: `
 class Foo {
   a = (): void => {};
-  b = function (): void {};
+  b = function(): void {};
 }
       `,
       errors: [
diff --git a/packages/eslint-plugin/tests/rules/unbound-method.test.ts b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
index 619b681c4ea..10f0b549762 100644
--- a/packages/eslint-plugin/tests/rules/unbound-method.test.ts
+++ b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
@@ -44,10 +44,10 @@ function addContainsMethodsClassInvalid(
 
 ruleTester.run('unbound-method', rule, {
   valid: [
-    'Promise.resolve().then(console.log)',
-    '["1", "2", "3"].map(Number.parseInt)',
+    'Promise.resolve().then(console.log);',
+    "['1', '2', '3'].map(Number.parseInt);",
     '[5.2, 7.1, 3.6].map(Math.floor);',
-    'const x = console.log',
+    'const x = console.log;',
     ...[
       'instance.bound();',
       'instance.unbound();',
@@ -150,14 +150,14 @@ ruleTester.run('unbound-method', rule, {
     ].map(addContainsMethodsClass),
     `
 interface RecordA {
-  readonly type: "A"
-  readonly a: {}
+  readonly type: 'A';
+  readonly a: {};
 }
 interface RecordB {
-  readonly type: "B"
-  readonly b: {}
+  readonly type: 'B';
+  readonly b: {};
 }
-type AnyRecord = RecordA | RecordB
+type AnyRecord = RecordA | RecordB;
 
 function test(obj: AnyRecord) {
   switch (obj.type) {
@@ -167,9 +167,9 @@ function test(obj: AnyRecord) {
     // https://github.com/typescript-eslint/typescript-eslint/issues/496
     `
 class CommunicationError {
-	constructor() {
+  constructor() {
     const x = CommunicationError.prototype;
-	}
+  }
 }
     `,
     `
@@ -192,8 +192,10 @@ function foo(instance: ContainsMethods | null) {
 
   instance?.bound++;
 
-  if (instance?.bound) { }
-  if (instance?.unbound) { }
+  if (instance?.bound) {
+  }
+  if (instance?.unbound) {
+  }
 
   typeof instance?.bound === 'function';
   typeof instance?.unbound === 'function';
@@ -202,13 +204,13 @@ function foo(instance: ContainsMethods | null) {
     // https://github.com/typescript-eslint/typescript-eslint/issues/1425
     `
 interface OptionalMethod {
-  mightBeDefined?(): void
+  mightBeDefined?(): void;
 }
 
 const x: OptionalMethod = {};
 declare const myCondition: boolean;
-if(myCondition || x.mightBeDefined) {
-  console.log('hello world')
+if (myCondition || x.mightBeDefined) {
+  console.log('hello world');
 }
     `,
   ],
@@ -296,7 +298,7 @@ class ContainsMethods {
 new ContainsMethods().unbound;
 
 ContainsMethods.unboundStatic;
-`,
+      `,
       options: [
         {
           ignoreStatic: true,
@@ -326,7 +328,7 @@ const x = CommunicationError.prototype.foo;
     },
     {
       // Promise.all is not auto-bound to Promise
-      code: 'const x = Promise.all',
+      code: 'const x = Promise.all;',
       errors: [
         {
           line: 1,
diff --git a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
index e3438ff7885..3c109d67a03 100644
--- a/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
+++ b/packages/eslint-plugin/tests/rules/unified-signatures.test.ts
@@ -13,151 +13,152 @@ ruleTester.run('unified-signatures', rule, {
 function g(): void;
 function g(a: number, b: number): void;
 function g(a?: number, b?: number): void {}
- `,
+    `,
     `
 function rest(...xs: number[]): void;
 function rest(xs: number[], y: string): void;
 function rest(...args: any[]) {}
-`,
+    `,
     `
 class C {
-    constructor();
-    constructor(a: number, b: number);
-    constructor(a?: number, b?: number) {}
+  constructor();
+  constructor(a: number, b: number);
+  constructor(a?: number, b?: number) {}
 
-    a(): void;
-    a(a: number, b: number): void;
-    a(a?: number, b?: number): void {}
+  a(): void;
+  a(a: number, b: number): void;
+  a(a?: number, b?: number): void {}
 }
-`,
+    `,
     // No error for arity difference greater than 1.
     `
 interface I {
-    a2(): void;
-    a2(x: number, y: number): void;
+  a2(): void;
+  a2(x: number, y: number): void;
 }
-`,
+    `,
     // No error for different return types.
     `
 interface I {
-    a4(): void;
-    a4(x: number): number;
+  a4(): void;
+  a4(x: number): number;
 }
-`,
+    `,
     // No error if one takes a type parameter and the other doesn't.
     `
 interface I {
-    a5<T>(x: T): T;
-    a5(x: number): number;
+  a5<T>(x: T): T;
+  a5(x: number): number;
 }
-`,
+    `,
     // No error if one is a rest parameter and other isn't.
     `
 interface I {
-    b2(x: string): void;
-    b2(...x: number[]): void;
+  b2(x: string): void;
+  b2(...x: number[]): void;
 }
-`,
+    `,
     // No error if both are rest parameters. (https://github.com/Microsoft/TypeScript/issues/5077)
     `
 interface I {
-    b3(...x: number[]): void;
-    b3(...x: string[]): void;
+  b3(...x: number[]): void;
+  b3(...x: string[]): void;
 }
-`,
+    `,
     // No error if one is optional and the other isn't.
     `
 interface I {
-    c3(x: number): void;
-    c3(x?: string): void;
+  c3(x: number): void;
+  c3(x?: string): void;
 }
-`,
+    `,
     // No error if they differ by 2 or more parameters.
     `
 interface I {
-    d2(x: string, y: number): void;
-    d2(x: number, y: string): void;
+  d2(x: string, y: number): void;
+  d2(x: number, y: string): void;
 }
-`,
+    `,
     // No conflict between static/non-static members.
     `
 declare class D {
-    static a();
-    a(x: number);
+  static a();
+  a(x: number);
 }
-`,
+    `,
     // Allow separate overloads if one is generic and the other isn't.
     `
 interface Generic<T> {
-    x(): void;
-    x(x: T[]): void;
+  x(): void;
+  x(x: T[]): void;
 }
-`,
+    `,
     // Allow signatures if the type is not equal.
     `
 interface I {
-  f(x1:number): void;
-  f(x1:boolean, x2?: number): void;
+  f(x1: number): void;
+  f(x1: boolean, x2?: number): void;
 }
-`,
+    `,
     // AllowType parameters that are not equal
     `
 function f<T extends number>(x: T[]): void;
 function f<T extends string>(x: T): void;
- `,
+    `,
     // Same name, different scopes
     `
 declare function foo(n: number): number;
 
-declare module "hello" {
+declare module 'hello' {
   function foo(n: number, s: string): number;
 }
-`,
+    `,
     // children of block not checked to match TSLint
     `
 {
-    function block(): number;
-    function block(n: number): number;
-    function block(n?: number): number {
-      return 3;
-    }
+  function block(): number;
+  function block(n: number): number;
+  function block(n?: number): number {
+    return 3;
+  }
 }
-`,
+    `,
     `
 export interface Foo {
   bar(baz: string): number[];
   bar(): string[];
 }
-`,
+    `,
     `
-declare module "foo" {
+declare module 'foo' {
   export default function(foo: number): string[];
 }
-`,
+    `,
     `
 export default function(foo: number): string[];
-`,
+    `,
     // https://github.com/typescript-eslint/typescript-eslint/issues/740
     `
-function p(key: string): Promise<string | undefined>
-function p(key: string, defaultValue: string): Promise<string>
-function p(key: string, defaultValue?: string): Promise<string | undefined>
-{
-  const obj: Record<string, string> = { }
-  return obj[key] || defaultValue
+function p(key: string): Promise<string | undefined>;
+function p(key: string, defaultValue: string): Promise<string>;
+function p(key: string, defaultValue?: string): Promise<string | undefined> {
+  const obj: Record<string, string> = {};
+  return obj[key] || defaultValue;
 }
-  `,
+    `,
     `
 interface I {
-    p<T>(x: T): Promise<T>;
-    p(x: number): Promise<number>;
+  p<T>(x: T): Promise<T>;
+  p(x: number): Promise<number>;
 }
-  `,
+    `,
     `
 function rest(...xs: number[]): Promise<number[]>;
 function rest(xs: number[], y: string): Promise<string>;
-async function rest(...args: any[], y?: string): Promise<number[] | string> { return y || args }
-`,
+async function rest(...args: any[], y?: string): Promise<number[] | string> {
+  return y || args;
+}
+    `,
   ],
   invalid: [
     {
@@ -165,9 +166,9 @@ async function rest(...args: any[], y?: string): Promise<number[] | string> { re
 function f(x: number): void;
 function f(x: string): void;
 function f(x: any): any {
-    return x;
+  return x;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -187,7 +188,7 @@ function f(x: any): any {
 function opt(xs?: number[]): void;
 function opt(xs: number[], y: string): void;
 function opt(...args: any[]) {}
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -204,11 +205,11 @@ function opt(...args: any[]) {}
       // For 3 or more overloads, mentions the line.
       code: `
 interface I {
-    a0(): void;
-    a0(x: string): string;
-    a0(x: number): void;
+  a0(): void;
+  a0(x: string): string;
+  a0(x: number): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -217,7 +218,7 @@ interface I {
               'This overload and the one on line 3 can be combined into one signature',
           },
           line: 5,
-          column: 8,
+          column: 6,
         },
       ],
     },
@@ -225,10 +226,10 @@ interface I {
       // Error for extra parameter.
       code: `
 interface I {
-    a1(): void;
-    a1(x: number): void;
+  a1(): void;
+  a1(x: number): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -237,7 +238,7 @@ interface I {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 8,
+          column: 6,
         },
       ],
     },
@@ -245,10 +246,10 @@ interface I {
       // Error for arity difference greater than 1 if the additional parameters are all optional/rest.
       code: `
 interface I {
-    a3(): void;
-    a3(x: number, y?: number, ...z: number[]): void;
+  a3(): void;
+  a3(x: number, y?: number, ...z: number[]): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingRestParameter',
@@ -257,7 +258,7 @@ interface I {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 31,
+          column: 29,
         },
       ],
     },
@@ -265,10 +266,10 @@ interface I {
       // Error if only one defines a rest parameter.
       code: `
 interface I {
-    b(): void;
-    b(...x: number[]): void;
+  b(): void;
+  b(...x: number[]): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingRestParameter',
@@ -277,7 +278,7 @@ interface I {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 7,
+          column: 5,
         },
       ],
     },
@@ -285,10 +286,10 @@ interface I {
       // Error if only one defines an optional parameter.
       code: `
 interface I {
-    c(): void;
-    c(x?: number): void;
+  c(): void;
+  c(x?: number): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -297,7 +298,7 @@ interface I {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 7,
+          column: 5,
         },
       ],
     },
@@ -305,10 +306,10 @@ interface I {
       // Error if both are optional.
       code: `
 interface I {
-    c2(x?: number): void;
-    c2(x?: string): void;
+  c2(x?: number): void;
+  c2(x?: string): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -319,7 +320,7 @@ interface I {
             type2: 'string',
           },
           line: 4,
-          column: 8,
+          column: 6,
         },
       ],
     },
@@ -327,10 +328,10 @@ interface I {
       // Error for different types (could be a union)
       code: `
 interface I {
-    d(x: number): void;
-    d(x: string): void;
+  d(x: number): void;
+  d(x: string): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -341,7 +342,7 @@ interface I {
             type2: 'string',
           },
           line: 4,
-          column: 7,
+          column: 5,
         },
       ],
     },
@@ -349,10 +350,10 @@ interface I {
       // Works for type literal and call signature too.
       code: `
 type T = {
-    (): void;
-    (x: number): void;
-}
-`,
+  (): void;
+  (x: number): void;
+};
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -361,7 +362,7 @@ type T = {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 6,
+          column: 4,
         },
       ],
     },
@@ -369,10 +370,10 @@ type T = {
       // Works for constructor.
       code: `
 declare class C {
-    constructor();
-    constructor(x: number);
+  constructor();
+  constructor(x: number);
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -381,7 +382,7 @@ declare class C {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
@@ -389,10 +390,10 @@ declare class C {
       // Works with unions.
       code: `
 interface I {
-    f(x: number);
-    f(x: string | boolean);
+  f(x: number);
+  f(x: string | boolean);
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -403,7 +404,7 @@ interface I {
             type2: 'string | boolean',
           },
           line: 4,
-          column: 7,
+          column: 5,
         },
       ],
     },
@@ -411,10 +412,10 @@ interface I {
       // Works with tuples.
       code: `
 interface I {
-    f(x: number);
-    f(x: [string, boolean]);
+  f(x: number);
+  f(x: [string, boolean]);
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -425,17 +426,17 @@ interface I {
             type2: '[string, boolean]',
           },
           line: 4,
-          column: 7,
+          column: 5,
         },
       ],
     },
     {
       code: `
 interface Generic<T> {
-    y(x: T[]): void;
-    y(x: T): void;
+  y(x: T[]): void;
+  y(x: T): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -446,7 +447,7 @@ interface Generic<T> {
             type2: 'T',
           },
           line: 4,
-          column: 7,
+          column: 5,
         },
       ],
     },
@@ -455,7 +456,7 @@ interface Generic<T> {
       code: `
 function f<T>(x: T[]): void;
 function f<T>(x: T): void;
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -475,7 +476,7 @@ function f<T>(x: T): void;
       code: `
 function f<T extends number>(x: T[]): void;
 function f<T extends number>(x: T): void;
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -494,10 +495,10 @@ function f<T extends number>(x: T): void;
       // Works with abstract
       code: `
 abstract class Foo {
-    public abstract f(x: number): void;
-    public abstract f(x: string): void;
+  public abstract f(x: number): void;
+  public abstract f(x: string): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -508,7 +509,7 @@ abstract class Foo {
             type2: 'string',
           },
           line: 4,
-          column: 23,
+          column: 21,
         },
       ],
     },
@@ -516,10 +517,10 @@ abstract class Foo {
       // Works with literals
       code: `
 interface Foo {
-    "f"(x: string): void;
-    "f"(x: number): void;
+  'f'(x: string): void;
+  'f'(x: number): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -530,7 +531,7 @@ interface Foo {
             type2: 'number',
           },
           line: 4,
-          column: 9,
+          column: 7,
         },
       ],
     },
@@ -538,10 +539,10 @@ interface Foo {
       // Works with new constructor
       code: `
 interface Foo {
-    new(x: string): Foo;
-    new(x: number): Foo;
+  new (x: string): Foo;
+  new (x: number): Foo;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -552,7 +553,7 @@ interface Foo {
             type2: 'number',
           },
           line: 4,
-          column: 9,
+          column: 8,
         },
       ],
     },
@@ -560,14 +561,14 @@ interface Foo {
       // Works with new computed properties
       code: `
 enum Enum {
-    Func = "function",
+  Func = 'function',
 }
 
 interface IFoo {
-    [Enum.Func](x: string): void;
-    [Enum.Func](x: number): void;
+  [Enum.Func](x: string): void;
+  [Enum.Func](x: number): void;
 }
-`,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -578,7 +579,7 @@ interface IFoo {
             type2: 'number',
           },
           line: 8,
-          column: 17,
+          column: 15,
         },
       ],
     },
@@ -586,10 +587,10 @@ interface IFoo {
       // Works with parameter properties. Note that this is invalid TypeScript syntax.
       code: `
 class Foo {
-    constructor(readonly x: number);
-    constructor(readonly x: string);
+  constructor(readonly x: number);
+  constructor(readonly x: string);
 }
-    `,
+      `,
       errors: [
         {
           messageId: 'singleParameterDifference',
@@ -600,7 +601,7 @@ class Foo {
             type2: 'string',
           },
           line: 4,
-          column: 17,
+          column: 15,
         },
       ],
     },
@@ -608,10 +609,10 @@ class Foo {
       // Works with parameter properties. Note that this is invalid TypeScript syntax.
       code: `
 class Foo {
-    constructor(readonly x: number);
-    constructor(readonly x: number, readonly y: string);
+  constructor(readonly x: number);
+  constructor(readonly x: number, readonly y: string);
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -620,7 +621,7 @@ class Foo {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 37,
+          column: 35,
         },
       ],
     },
@@ -628,10 +629,10 @@ class Foo {
       // Works with parameter properties. Note that this is invalid TypeScript syntax.
       code: `
 class Foo {
-    constructor(readonly x: number);
-    constructor(readonly x: number, readonly y?: string, readonly z?: string);
+  constructor(readonly x: number);
+  constructor(readonly x: number, readonly y?: string, readonly z?: string);
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -640,7 +641,7 @@ class Foo {
               'These overloads can be combined into one signature',
           },
           line: 4,
-          column: 58,
+          column: 56,
         },
       ],
     },
@@ -648,7 +649,7 @@ class Foo {
       code: `
 export function foo(line: number): number;
 export function foo(line: number, character?: number): number;
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -665,7 +666,7 @@ export function foo(line: number, character?: number): number;
       code: `
 declare function foo(line: number): number;
 export function foo(line: number, character?: number): number;
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -680,11 +681,11 @@ export function foo(line: number, character?: number): number;
     },
     {
       code: `
-declare module "foo" {
+declare module 'foo' {
   export default function(foo: number): string[];
   export default function(foo: number, bar?: string): string[];
 }
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',
@@ -697,7 +698,7 @@ declare module "foo" {
       code: `
 export default function(foo: number): string[];
 export default function(foo: number, bar?: string): string[];
-`,
+      `,
       errors: [
         {
           messageId: 'omittingSingleParameter',

From 9d53c761983dd964109b9f13eb9bfe20caf9defb Mon Sep 17 00:00:00 2001
From: Alexander T <alexander.tarasyuk@outlook.com>
Date: Wed, 1 Apr 2020 18:41:44 +0300
Subject: [PATCH 17/36] fix(eslint-plugin): [no-throw-literal] fix crash caused
 by getBaseTypes (#1830)

---
 .../src/rules/no-throw-literal.ts             |  9 +++---
 .../tests/rules/no-throw-literal.test.ts      | 31 +++++++++++++++++++
 2 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/no-throw-literal.ts b/packages/eslint-plugin/src/rules/no-throw-literal.ts
index c8c5bcc1837..ffa8a614e6b 100644
--- a/packages/eslint-plugin/src/rules/no-throw-literal.ts
+++ b/packages/eslint-plugin/src/rules/no-throw-literal.ts
@@ -43,10 +43,11 @@ export default util.createRule({
         }
       }
 
-      const baseTypes = checker.getBaseTypes(type as ts.InterfaceType);
-      for (const baseType of baseTypes) {
-        if (isErrorLike(baseType)) {
-          return true;
+      if (symbol.flags & (ts.SymbolFlags.Class | ts.SymbolFlags.Interface)) {
+        for (const baseType of checker.getBaseTypes(type as ts.InterfaceType)) {
+          if (isErrorLike(baseType)) {
+            return true;
+          }
         }
       }
 
diff --git a/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts b/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts
index 1367c6a8f69..7d7b95acbb2 100644
--- a/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-throw-literal.test.ts
@@ -321,5 +321,36 @@ throw new CustomError();
         },
       ],
     },
+    {
+      code: `
+function foo<T>() {
+  const res: T;
+  throw res;
+}
+      `,
+      errors: [
+        {
+          messageId: 'object',
+          line: 4,
+          column: 9,
+        },
+      ],
+    },
+    {
+      code: `
+function foo<T>(fn: () => Promise<T>) {
+  const promise = fn();
+  const res = promise.then(() => {}).catch(() => {});
+  throw res;
+}
+      `,
+      errors: [
+        {
+          messageId: 'object',
+          line: 5,
+          column: 9,
+        },
+      ],
+    },
   ],
 });

From 1f0ff41aa1bc3b7c5330b2f5fe22e24bf578a6b2 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Wed, 1 Apr 2020 15:33:27 -0700
Subject: [PATCH 18/36] fix(typescript-estree): add support for TS3.9 extra
 file extensions (#1833)

---
 .../src/create-program/WatchCompilerHostOfConfigFile.ts   | 1 +
 .../src/create-program/createWatchProgram.ts              | 8 ++++++++
 2 files changed, 9 insertions(+)

diff --git a/packages/typescript-estree/src/create-program/WatchCompilerHostOfConfigFile.ts b/packages/typescript-estree/src/create-program/WatchCompilerHostOfConfigFile.ts
index 471a6d6b6fe..565f58417c8 100644
--- a/packages/typescript-estree/src/create-program/WatchCompilerHostOfConfigFile.ts
+++ b/packages/typescript-estree/src/create-program/WatchCompilerHostOfConfigFile.ts
@@ -32,6 +32,7 @@ interface WatchCompilerHostOfConfigFile<T extends ts.BuilderProgram>
   onCachedDirectoryStructureHostCreate(
     host: CachedDirectoryStructureHost,
   ): void;
+  extraFileExtensions?: readonly ts.FileExtensionInfo[];
 }
 
 export { WatchCompilerHostOfConfigFile };
diff --git a/packages/typescript-estree/src/create-program/createWatchProgram.ts b/packages/typescript-estree/src/create-program/createWatchProgram.ts
index 682e1d7c731..cf31a5c383d 100644
--- a/packages/typescript-estree/src/create-program/createWatchProgram.ts
+++ b/packages/typescript-estree/src/create-program/createWatchProgram.ts
@@ -314,6 +314,14 @@ function createWatchProgram(
       );
     oldOnDirectoryStructureHostCreate(host);
   };
+  // This works only on 3.9
+  watchCompilerHost.extraFileExtensions = extra.extraFileExtensions.map(
+    extension => ({
+      extension,
+      isMixedContent: true,
+      scriptKind: ts.ScriptKind.Deferred,
+    }),
+  );
   watchCompilerHost.trace = log;
 
   // Since we don't want to asynchronously update program we want to disable timeout methods

From 485e90213a0f8baac0587f7d56925448883fc5bd Mon Sep 17 00:00:00 2001
From: Tim Kraut <Tim.Kraut@web.de>
Date: Fri, 3 Apr 2020 04:41:09 +0200
Subject: [PATCH 19/36] feat(eslint-plugin): sort members alphabetically (#263)

Co-authored-by: Brad Zacher <brad.zacher@gmail.com>
---
 .../docs/rules/member-ordering.md             |  202 +-
 .../src/rules/member-ordering.ts              |  709 +++--
 .../tests/rules/member-ordering.test.ts       | 2539 ++++++++++++++++-
 .../src/ts-estree/ts-estree.ts                |    2 -
 4 files changed, 2958 insertions(+), 494 deletions(-)

diff --git a/packages/eslint-plugin/docs/rules/member-ordering.md b/packages/eslint-plugin/docs/rules/member-ordering.md
index d028d844368..cccf2bbbe0a 100644
--- a/packages/eslint-plugin/docs/rules/member-ordering.md
+++ b/packages/eslint-plugin/docs/rules/member-ordering.md
@@ -1,29 +1,54 @@
 # Require a consistent member declaration order (`member-ordering`)
 
-A consistent ordering of fields, methods and constructors can make interfaces, type literals, classes and class
-expressions easier to read, navigate and edit.
+A consistent ordering of fields, methods and constructors can make interfaces, type literals, classes and class expressions easier to read, navigate and edit.
 
 ## Rule Details
 
-This rule aims to standardize the way class declarations, class expressions, interfaces and type literals are structured.
+This rule aims to standardize the way class declarations, class expressions, interfaces and type literals are structured and ordered.
 
-It allows to group members by their type (e.g. `public-static-field`, `protected-static-field`, `private-static-field`, `public-instance-field`, ...). By default, their order is the same inside `classes`, `classExpressions`, `interfaces` and `typeLiterals` (note: not all member types apply to `interfaces` and `typeLiterals`). It is possible to define the order for any of those individually or to change the default order for all of them by setting the `default` option.
+### Grouping and sorting member groups
+
+It allows to group members by their type (e.g. `public-static-field`, `protected-static-field`, `private-static-field`, `public-instance-field`, ...) and enforce a certain order for these groups. By default, their order is the same inside `classes`, `classExpressions`, `interfaces` and `typeLiterals` (note: not all member types apply to `interfaces` and `typeLiterals`). It is possible to define the order for any of those individually or to change the default order for all of them by setting the `default` option.
+
+### Sorting members
+
+Besides grouping the members and sorting their groups, this rule also allows to sort the members themselves (e.g. `a`, `b`, `c`, ...). You have 2 options: Sort all of them while ignoring their type or sort them while respecting their types (e.g. sort all fields in an interface alphabetically).
 
 ## Options
 
+These options allow to specify how to group the members and sort their groups.
+
+- Sort groups, don't enforce member order: Use `memberTypes`
+- Sort members, don't enforce group order: Use `order`
+- Sort members within groups: Use `memberTypes` and `order`
+
 ```ts
+type TypeOptions<T> =
+  | {
+    memberTypes: Array<T> | 'never',
+    order?: 'alphabetically' | 'as-written',
+  }
+  | {
+    order: 'alphabetically',
+  };
+
 {
-  default?: Array<MemberType> | never
-  classes?: Array<MemberType> | never
-  classExpressions?: Array<MemberType> | never
+  default?: TypeOptions<MemberTypes>,
+
+  classes?: TypeOptions<MemberTypes>,
+  classExpressions?: TypeOptions<MemberTypes>,
 
-  interfaces?: ['signature' | 'field' | 'method' | 'constructor'] | never
-  typeLiterals?: ['signature' | 'field' | 'method' | 'constructor'] | never
+  interfaces?: TypeOptions<'signature' | 'field' | 'method' | 'constructor'>,
+  typeLiterals?: TypeOptions<'signature' | 'field' | 'method' | 'constructor'>,
 }
 ```
 
 See below for the possible definitions of `MemberType`.
 
+### Deprecated syntax
+
+Note: There is a deprecated syntax to specify the member types as an array.
+
 ### Member types (granular form)
 
 There are multiple ways to specify the member types. The most explicit and granular form is the following:
@@ -138,62 +163,72 @@ The third grouping option is to ignore both scope and accessibility.
 
 The default configuration looks as follows:
 
-```json
+```json5
 {
-  "default": [
-    "signature",
+  default: [
+    // Index signature
+    'signature',
 
-    "public-static-field",
-    "protected-static-field",
-    "private-static-field",
+    // Fields
+    'public-static-field',
+    'protected-static-field',
+    'private-static-field',
 
-    "public-instance-field",
-    "protected-instance-field",
-    "private-instance-field",
+    'public-instance-field',
+    'protected-instance-field',
+    'private-instance-field',
 
-    "public-abstract-field",
-    "protected-abstract-field",
-    "private-abstract-field",
+    'public-abstract-field',
+    'protected-abstract-field',
+    'private-abstract-field',
 
-    "public-field",
-    "protected-field",
-    "private-field",
+    'public-field',
+    'protected-field',
+    'private-field',
 
-    "static-field",
-    "instance-field",
-    "abstract-field",
+    'static-field',
+    'instance-field',
+    'abstract-field',
 
-    "field",
+    'field',
 
-    "constructor",
+    // Constructors
+    'public-constructor',
+    'protected-constructor',
+    'private-constructor',
 
-    "public-static-method",
-    "protected-static-method",
-    "private-static-method",
+    'constructor',
 
-    "public-instance-method",
-    "protected-instance-method",
-    "private-instance-method",
+    // Methods
+    'public-static-method',
+    'protected-static-method',
+    'private-static-method',
 
-    "public-abstract-method",
-    "protected-abstract-method",
-    "private-abstract-method",
+    'public-instance-method',
+    'protected-instance-method',
+    'private-instance-method',
 
-    "public-method",
-    "protected-method",
-    "private-method",
+    'public-abstract-method',
+    'protected-abstract-method',
+    'private-abstract-method',
 
-    "static-method",
-    "instance-method",
-    "abstract-method",
+    'public-method',
+    'protected-method',
+    'private-method',
 
-    "method"
-  ]
+    'static-method',
+    'instance-method',
+    'abstract-method',
+
+    'method',
+  ],
 }
 ```
 
 Note: The default configuration contains member group types which contain other member types (see above). This is intentional to provide better error messages.
 
+Note: By default, the members are not sorted. If you want to sort them alphabetically, you have to provide a custom configuration.
+
 ## Examples
 
 ### Custom `default` configuration
@@ -448,7 +483,7 @@ const foo = class {
 };
 ```
 
-Issue: Public static fields should come first, followed by static fields and instance fields.
+Note: Public static fields should come first, followed by static fields and instance fields.
 
 ##### Correct examples
 
@@ -542,21 +577,19 @@ class Foo {
 
 ##### Correct example
 
-Examples of **correct** code for `{ "classes": [...] }` option:
-
 ```ts
 class Foo {
   private C: string; // (irrelevant)
 
   public D: string; // (irrelevant)
 
-  public static E: string; // -> public static field
+  public B(): void {} // -> public instance method
 
   constructor() {} // (irrelevant)
 
   public static A(): void {} // (irrelevant)
 
-  public B(): void {} // -> public instance method
+  public static E: string; // -> public static field
 }
 ```
 
@@ -712,6 +745,73 @@ type Foo = {
 };
 ```
 
+### Sorting alphabetically within member groups
+
+It is possible to sort all members within a group alphabetically.
+
+#### Configuration: `{ default: { memberTypes: <Default Order>, order: 'alphabetically' } }`
+
+This will apply the default order (see above) and enforce an alphabetic order within each group.
+
+##### Incorrect examples
+
+```ts
+interface Foo {
+  a: x;
+  b: x;
+  c: x;
+
+  new (): Bar;
+  (): Baz;
+
+  a(): void;
+  b(): void;
+  c(): void;
+
+  // Wrong group order, should be placed before all field definitions
+  [a: string]: number;
+}
+```
+
+```ts
+interface Foo {
+  [a: string]: number;
+
+  a: x;
+  b: x;
+  c: x;
+
+  new (): Bar;
+  (): Baz;
+
+  // Wrong alphabetic order within group
+  c(): void;
+  b(): void;
+  a(): void;
+}
+```
+
+### Sorting alphabetically while ignoring member groups
+
+It is also possible to sort all members and ignore the member groups completely.
+
+#### Configuration: `{ default: { memberTypes: 'never', order: 'alphabetically' } }`
+
+##### Incorrect example
+
+```ts
+interface Foo {
+  b(): void;
+  a: b;
+
+  [a: string]: number; // Order doesn't matter (no sortable identifier)
+  new (): Bar; // Order doesn't matter (no sortable identifier)
+  (): Baz; // Order doesn't matter (no sortable identifier)
+}
+```
+
+Note: Wrong alphabetic order `b(): void` should come after `a: b`.
+
 ## When Not To Use It
 
 If you don't care about the general structure of your classes and interfaces, then you will not need this rule.
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index b9fb0ee8ef0..14ddcc236a9 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -1,12 +1,21 @@
 import {
-  TSESTree,
   AST_NODE_TYPES,
+  TSESLint,
+  TSESTree,
 } from '@typescript-eslint/experimental-utils';
 import * as util from '../util';
 
-type MessageIds = 'incorrectOrder';
-type OrderConfig = string[] | 'never';
-type Options = [
+export type MessageIds = 'incorrectGroupOrder' | 'incorrectOrder';
+
+interface SortedOrderConfig {
+  memberTypes?: string[] | 'never';
+  order: 'alphabetically' | 'as-written';
+}
+
+type OrderConfig = string[] | SortedOrderConfig | 'never';
+type Member = TSESTree.ClassElement | TSESTree.TypeElement;
+
+export type Options = [
   {
     default?: OrderConfig;
     classes?: OrderConfig;
@@ -16,30 +25,287 @@ type Options = [
   },
 ];
 
-const allMemberTypes = ['field', 'method', 'constructor'].reduce<string[]>(
-  (all, type) => {
-    all.push(type);
+const neverConfig = {
+  type: 'string',
+  enum: ['never'],
+};
+
+const arrayConfig = (memberTypes: string[]): object => ({
+  type: 'array',
+  items: {
+    enum: memberTypes,
+  },
+});
+
+const objectConfig = (memberTypes: string[]): object => ({
+  type: 'object',
+  properties: {
+    memberTypes: {
+      oneOf: [arrayConfig(memberTypes), neverConfig],
+    },
+    order: {
+      type: 'string',
+      enum: ['alphabetically', 'as-written'],
+    },
+  },
+  additionalProperties: false,
+});
+
+export const defaultOrder = [
+  // Index signature
+  'signature',
 
-    ['public', 'protected', 'private'].forEach(accessibility => {
+  // Fields
+  'public-static-field',
+  'protected-static-field',
+  'private-static-field',
+
+  'public-instance-field',
+  'protected-instance-field',
+  'private-instance-field',
+
+  'public-abstract-field',
+  'protected-abstract-field',
+  'private-abstract-field',
+
+  'public-field',
+  'protected-field',
+  'private-field',
+
+  'static-field',
+  'instance-field',
+  'abstract-field',
+
+  'field',
+
+  // Constructors
+  'public-constructor',
+  'protected-constructor',
+  'private-constructor',
+
+  'constructor',
+
+  // Methods
+  'public-static-method',
+  'protected-static-method',
+  'private-static-method',
+
+  'public-instance-method',
+  'protected-instance-method',
+  'private-instance-method',
+
+  'public-abstract-method',
+  'protected-abstract-method',
+  'private-abstract-method',
+
+  'public-method',
+  'protected-method',
+  'private-method',
+
+  'static-method',
+  'instance-method',
+  'abstract-method',
+
+  'method',
+];
+
+const allMemberTypes = ['signature', 'field', 'method', 'constructor'].reduce<
+  string[]
+>((all, type) => {
+  all.push(type);
+
+  ['public', 'protected', 'private'].forEach(accessibility => {
+    if (type !== 'signature') {
       all.push(`${accessibility}-${type}`); // e.g. `public-field`
+    }
 
-      if (type !== 'constructor') {
-        // There is no `static-constructor` or `instance-constructor or `abstract-constructor`
-        ['static', 'instance', 'abstract'].forEach(scope => {
-          if (!all.includes(`${scope}-${type}`)) {
-            all.push(`${scope}-${type}`);
-          }
+    if (type !== 'constructor' && type !== 'signature') {
+      // There is no `static-constructor` or `instance-constructor` or `abstract-constructor`
+      ['static', 'instance', 'abstract'].forEach(scope => {
+        if (!all.includes(`${scope}-${type}`)) {
+          all.push(`${scope}-${type}`);
+        }
 
-          all.push(`${accessibility}-${scope}-${type}`);
-        });
-      }
-    });
+        all.push(`${accessibility}-${scope}-${type}`);
+      });
+    }
+  });
 
-    return all;
-  },
-  [],
-);
-allMemberTypes.unshift('signature');
+  return all;
+}, []);
+
+const functionExpressions = [
+  AST_NODE_TYPES.FunctionExpression,
+  AST_NODE_TYPES.ArrowFunctionExpression,
+];
+
+/**
+ * Gets the node type.
+ *
+ * @param node the node to be evaluated.
+ */
+function getNodeType(node: Member): string | null {
+  // TODO: add missing TSCallSignatureDeclaration
+  switch (node.type) {
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.MethodDefinition:
+      return node.kind;
+    case AST_NODE_TYPES.TSMethodSignature:
+      return 'method';
+    case AST_NODE_TYPES.TSConstructSignatureDeclaration:
+      return 'constructor';
+    case AST_NODE_TYPES.TSAbstractClassProperty:
+    case AST_NODE_TYPES.ClassProperty:
+      return node.value && functionExpressions.includes(node.value.type)
+        ? 'method'
+        : 'field';
+    case AST_NODE_TYPES.TSPropertySignature:
+      return 'field';
+    case AST_NODE_TYPES.TSIndexSignature:
+      return 'signature';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Gets the member name based on the member type.
+ *
+ * @param node the node to be evaluated.
+ * @param sourceCode
+ */
+function getMemberName(
+  node: Member,
+  sourceCode: TSESLint.SourceCode,
+): string | null {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSPropertySignature:
+    case AST_NODE_TYPES.TSMethodSignature:
+    case AST_NODE_TYPES.TSAbstractClassProperty:
+    case AST_NODE_TYPES.ClassProperty:
+      return util.getNameFromMember(node, sourceCode);
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.MethodDefinition:
+      return node.kind === 'constructor'
+        ? 'constructor'
+        : util.getNameFromMember(node, sourceCode);
+    case AST_NODE_TYPES.TSConstructSignatureDeclaration:
+      return 'new';
+    case AST_NODE_TYPES.TSIndexSignature:
+      return util.getNameFromIndexSignature(node);
+    default:
+      return null;
+  }
+}
+
+/**
+ * Gets the calculated rank using the provided method definition.
+ * The algorithm is as follows:
+ * - Get the rank based on the accessibility-scope-type name, e.g. public-instance-field
+ * - If there is no order for accessibility-scope-type, then strip out the accessibility.
+ * - If there is no order for scope-type, then strip out the scope.
+ * - If there is no order for type, then return -1
+ * @param memberGroups the valid names to be validated.
+ * @param orderConfig the current order to be validated.
+ *
+ * @return Index of the matching member type in the order configuration.
+ */
+function getRankOrder(memberGroups: string[], orderConfig: string[]): number {
+  let rank = -1;
+  const stack = memberGroups.slice(); // Get a copy of the member groups
+
+  while (stack.length > 0 && rank === -1) {
+    rank = orderConfig.indexOf(stack.shift()!);
+  }
+
+  return rank;
+}
+
+/**
+ * Gets the rank of the node given the order.
+ * @param node the node to be evaluated.
+ * @param orderConfig the current order to be validated.
+ * @param supportsModifiers a flag indicating whether the type supports modifiers (scope or accessibility) or not.
+ */
+function getRank(
+  node: Member,
+  orderConfig: string[],
+  supportsModifiers: boolean,
+): number {
+  const type = getNodeType(node);
+
+  if (type === null) {
+    // shouldn't happen but just in case, put it on the end
+    return orderConfig.length - 1;
+  }
+
+  const abstract =
+    node.type === AST_NODE_TYPES.TSAbstractClassProperty ||
+    node.type === AST_NODE_TYPES.TSAbstractMethodDefinition;
+
+  const scope =
+    'static' in node && node.static
+      ? 'static'
+      : abstract
+      ? 'abstract'
+      : 'instance';
+  const accessibility =
+    'accessibility' in node && node.accessibility
+      ? node.accessibility
+      : 'public';
+
+  // Collect all existing member groups (e.g. 'public-instance-field', 'instance-field', 'public-field', 'constructor' etc.)
+  const memberGroups = [];
+
+  if (supportsModifiers) {
+    if (type !== 'constructor') {
+      // Constructors have no scope
+      memberGroups.push(`${accessibility}-${scope}-${type}`);
+      memberGroups.push(`${scope}-${type}`);
+    }
+
+    memberGroups.push(`${accessibility}-${type}`);
+  }
+
+  memberGroups.push(type);
+
+  return getRankOrder(memberGroups, orderConfig);
+}
+
+/**
+ * Gets the lowest possible rank higher than target.
+ * e.g. given the following order:
+ *   ...
+ *   public-static-method
+ *   protected-static-method
+ *   private-static-method
+ *   public-instance-method
+ *   protected-instance-method
+ *   private-instance-method
+ *   ...
+ * and considering that a public-instance-method has already been declared, so ranks contains
+ * public-instance-method, then the lowest possible rank for public-static-method is
+ * public-instance-method.
+ * @param ranks the existing ranks in the object.
+ * @param target the target rank.
+ * @param order the current order to be validated.
+ * @returns the name of the lowest possible rank without dashes (-).
+ */
+function getLowestRank(
+  ranks: number[],
+  target: number,
+  order: string[],
+): string {
+  let lowest = ranks[ranks.length - 1];
+
+  ranks.forEach(rank => {
+    if (rank > target) {
+      lowest = Math.min(lowest, rank);
+    }
+  });
+
+  return order[lowest].replace(/-/g, ' ');
+}
 
 export default util.createRule<Options, MessageIds>({
   name: 'member-ordering',
@@ -52,6 +318,8 @@ export default util.createRule<Options, MessageIds>({
     },
     messages: {
       incorrectOrder:
+        'Member "{{member}}" should be declared before member "{{beforeMember}}".',
+      incorrectGroupOrder:
         'Member {{name}} should be declared before all {{rank}} definitions.',
     },
     schema: [
@@ -60,67 +328,37 @@ export default util.createRule<Options, MessageIds>({
         properties: {
           default: {
             oneOf: [
-              {
-                enum: ['never'],
-              },
-              {
-                type: 'array',
-                items: {
-                  enum: allMemberTypes,
-                },
-              },
+              neverConfig,
+              arrayConfig(allMemberTypes),
+              objectConfig(allMemberTypes),
             ],
           },
           classes: {
             oneOf: [
-              {
-                enum: ['never'],
-              },
-              {
-                type: 'array',
-                items: {
-                  enum: allMemberTypes,
-                },
-              },
+              neverConfig,
+              arrayConfig(allMemberTypes),
+              objectConfig(allMemberTypes),
             ],
           },
           classExpressions: {
             oneOf: [
-              {
-                enum: ['never'],
-              },
-              {
-                type: 'array',
-                items: {
-                  enum: allMemberTypes,
-                },
-              },
+              neverConfig,
+              arrayConfig(allMemberTypes),
+              objectConfig(allMemberTypes),
             ],
           },
           interfaces: {
             oneOf: [
-              {
-                enum: ['never'],
-              },
-              {
-                type: 'array',
-                items: {
-                  enum: ['signature', 'field', 'method', 'constructor'],
-                },
-              },
+              neverConfig,
+              arrayConfig(['signature', 'field', 'method', 'constructor']),
+              objectConfig(['signature', 'field', 'method', 'constructor']),
             ],
           },
           typeLiterals: {
             oneOf: [
-              {
-                enum: ['never'],
-              },
-              {
-                type: 'array',
-                items: {
-                  enum: ['signature', 'field', 'method', 'constructor'],
-                },
-              },
+              neverConfig,
+              arrayConfig(['signature', 'field', 'method', 'constructor']),
+              objectConfig(['signature', 'field', 'method', 'constructor']),
             ],
           },
         },
@@ -130,263 +368,140 @@ export default util.createRule<Options, MessageIds>({
   },
   defaultOptions: [
     {
-      default: [
-        'signature',
-
-        'public-static-field',
-        'protected-static-field',
-        'private-static-field',
-
-        'public-instance-field',
-        'protected-instance-field',
-        'private-instance-field',
-
-        'public-abstract-field',
-        'protected-abstract-field',
-        'private-abstract-field',
-
-        'public-field',
-        'protected-field',
-        'private-field',
-
-        'static-field',
-        'instance-field',
-        'abstract-field',
-
-        'field',
-
-        'constructor',
-
-        'public-static-method',
-        'protected-static-method',
-        'private-static-method',
-
-        'public-instance-method',
-        'protected-instance-method',
-        'private-instance-method',
-
-        'public-abstract-method',
-        'protected-abstract-method',
-        'private-abstract-method',
-
-        'public-method',
-        'protected-method',
-        'private-method',
-
-        'static-method',
-        'instance-method',
-        'abstract-method',
-
-        'method',
-      ],
+      default: defaultOrder,
     },
   ],
   create(context, [options]) {
-    const sourceCode = context.getSourceCode();
-
-    const functionExpressions = [
-      AST_NODE_TYPES.FunctionExpression,
-      AST_NODE_TYPES.ArrowFunctionExpression,
-    ];
-
     /**
-     * Gets the node type.
-     * @param node the node to be evaluated.
-     */
-    function getNodeType(
-      node: TSESTree.ClassElement | TSESTree.TypeElement,
-    ): string | null {
-      // TODO: add missing TSCallSignatureDeclaration
-      switch (node.type) {
-        case AST_NODE_TYPES.TSAbstractMethodDefinition:
-        case AST_NODE_TYPES.MethodDefinition:
-          return node.kind;
-        case AST_NODE_TYPES.TSMethodSignature:
-          return 'method';
-        case AST_NODE_TYPES.TSConstructSignatureDeclaration:
-          return 'constructor';
-        case AST_NODE_TYPES.TSAbstractClassProperty:
-        case AST_NODE_TYPES.ClassProperty:
-          return node.value && functionExpressions.includes(node.value.type)
-            ? 'method'
-            : 'field';
-        case AST_NODE_TYPES.TSPropertySignature:
-          return 'field';
-        case AST_NODE_TYPES.TSIndexSignature:
-          return 'signature';
-        default:
-          return null;
-      }
-    }
-
-    /**
-     * Gets the member name based on the member type.
-     * @param node the node to be evaluated.
-     */
-    function getMemberName(
-      node: TSESTree.ClassElement | TSESTree.TypeElement,
-    ): string | null {
-      switch (node.type) {
-        case AST_NODE_TYPES.TSPropertySignature:
-        case AST_NODE_TYPES.TSMethodSignature:
-        case AST_NODE_TYPES.TSAbstractClassProperty:
-        case AST_NODE_TYPES.ClassProperty:
-          return util.getNameFromMember(node, sourceCode);
-        case AST_NODE_TYPES.TSAbstractMethodDefinition:
-        case AST_NODE_TYPES.MethodDefinition:
-          return node.kind === 'constructor'
-            ? 'constructor'
-            : util.getNameFromMember(node, sourceCode);
-        case AST_NODE_TYPES.TSConstructSignatureDeclaration:
-          return 'new';
-        case AST_NODE_TYPES.TSIndexSignature:
-          return util.getNameFromIndexSignature(node);
-        default:
-          return null;
-      }
-    }
-
-    /**
-     * Gets the calculated rank using the provided method definition.
-     * The algorithm is as follows:
-     * - Get the rank based on the accessibility-scope-type name, e.g. public-instance-field
-     * - If there is no order for accessibility-scope-type, then strip out the accessibility.
-     * - If there is no order for scope-type, then strip out the scope.
-     * - If there is no order for type, then return -1
-     * @param memberTypes the valid names to be validated.
-     * @param order the current order to be validated.
+     * Checks if the member groups are correctly sorted.
      *
-     * @return Index of the matching member type in the order configuration.
-     */
-    function getRankOrder(memberTypes: string[], order: string[]): number {
-      let rank = -1;
-      const stack = memberTypes.slice(); // Get a copy of the member types
-
-      while (stack.length > 0 && rank === -1) {
-        rank = order.indexOf(stack.shift()!);
-      }
-
-      return rank;
-    }
-
-    /**
-     * Gets the rank of the node given the order.
-     * @param node the node to be evaluated.
-     * @param order the current order to be validated.
-     * @param supportsModifiers a flag indicating whether the type supports modifiers (scope or accessibility) or not.
+     * @param members Members to be validated.
+     * @param groupOrder Group order to be validated.
+     * @param supportsModifiers A flag indicating whether the type supports modifiers (scope or accessibility) or not.
+     *
+     * @return Array of member groups or null if one of the groups is not correctly sorted.
      */
-    function getRank(
-      node: TSESTree.ClassElement | TSESTree.TypeElement,
-      order: string[],
+    function checkGroupSort(
+      members: Member[],
+      groupOrder: string[],
       supportsModifiers: boolean,
-    ): number {
-      const type = getNodeType(node);
-      if (type === null) {
-        // shouldn't happen but just in case, put it on the end
-        return order.length - 1;
-      }
-
-      const abstract =
-        node.type === AST_NODE_TYPES.TSAbstractClassProperty ||
-        node.type === AST_NODE_TYPES.TSAbstractMethodDefinition;
-
-      const scope =
-        'static' in node && node.static
-          ? 'static'
-          : abstract
-          ? 'abstract'
-          : 'instance';
-      const accessibility =
-        'accessibility' in node && node.accessibility
-          ? node.accessibility
-          : 'public';
-
-      const memberTypes = [];
-
-      if (supportsModifiers) {
-        if (type !== 'constructor') {
-          // Constructors have no scope
-          memberTypes.push(`${accessibility}-${scope}-${type}`);
-          memberTypes.push(`${scope}-${type}`);
+    ): Array<Member[]> | null {
+      const previousRanks: number[] = [];
+      const memberGroups: Array<Member[]> = [];
+      let isCorrectlySorted = true;
+
+      // Find first member which isn't correctly sorted
+      members.forEach(member => {
+        const rank = getRank(member, groupOrder, supportsModifiers);
+        const name = getMemberName(member, context.getSourceCode());
+        const rankLastMember = previousRanks[previousRanks.length - 1];
+
+        if (rank !== -1) {
+          // Works for 1st item because x < undefined === false for any x (typeof string)
+          if (rank < rankLastMember) {
+            context.report({
+              node: member,
+              messageId: 'incorrectGroupOrder',
+              data: {
+                name,
+                rank: getLowestRank(previousRanks, rank, groupOrder),
+              },
+            });
+
+            isCorrectlySorted = false;
+          } else if (rank === rankLastMember) {
+            // Same member group --> Push to existing member group array
+            memberGroups[memberGroups.length - 1].push(member);
+          } else {
+            // New member group --> Create new member group array
+            previousRanks.push(rank);
+            memberGroups.push([member]);
+          }
         }
+      });
 
-        memberTypes.push(`${accessibility}-${type}`);
-      }
-
-      memberTypes.push(type);
-
-      return getRankOrder(memberTypes, order);
+      return isCorrectlySorted ? memberGroups : null;
     }
 
     /**
-     * Gets the lowest possible rank higher than target.
-     * e.g. given the following order:
-     *   ...
-     *   public-static-method
-     *   protected-static-method
-     *   private-static-method
-     *   public-instance-method
-     *   protected-instance-method
-     *   private-instance-method
-     *   ...
-     * and considering that a public-instance-method has already been declared, so ranks contains
-     * public-instance-method, then the lowest possible rank for public-static-method is
-     * public-instance-method.
-     * @param ranks the existing ranks in the object.
-     * @param target the target rank.
-     * @param order the current order to be validated.
-     * @returns the name of the lowest possible rank without dashes (-).
+     * Checks if the members are alphabetically sorted.
+     *
+     * @param members Members to be validated.
+     *
+     * @return True if all members are correctly sorted.
      */
-    function getLowestRank(
-      ranks: number[],
-      target: number,
-      order: string[],
-    ): string {
-      let lowest = ranks[ranks.length - 1];
-
-      ranks.forEach(rank => {
-        if (rank > target) {
-          lowest = Math.min(lowest, rank);
+    function checkAlphaSort(members: Member[]): boolean {
+      let previousName = '';
+      let isCorrectlySorted = true;
+
+      // Find first member which isn't correctly sorted
+      members.forEach(member => {
+        const name = getMemberName(member, context.getSourceCode());
+
+        // Note: Not all members have names
+        if (name) {
+          if (name < previousName) {
+            context.report({
+              node: member,
+              messageId: 'incorrectOrder',
+              data: {
+                member: name,
+                beforeMember: previousName,
+              },
+            });
+
+            isCorrectlySorted = false;
+          }
+
+          previousName = name;
         }
       });
 
-      return order[lowest].replace(/-/g, ' ');
+      return isCorrectlySorted;
     }
 
     /**
      * Validates if all members are correctly sorted.
      *
      * @param members Members to be validated.
-     * @param order Current order to be validated.
+     * @param orderConfig Order config to be validated.
      * @param supportsModifiers A flag indicating whether the type supports modifiers (scope or accessibility) or not.
      */
     function validateMembersOrder(
-      members: (TSESTree.ClassElement | TSESTree.TypeElement)[],
-      order: OrderConfig,
+      members: Member[],
+      orderConfig: OrderConfig,
       supportsModifiers: boolean,
     ): void {
-      if (members && order !== 'never') {
-        const previousRanks: number[] = [];
-
-        // Find first member which isn't correctly sorted
-        members.forEach(member => {
-          const rank = getRank(member, order, supportsModifiers);
-
-          if (rank !== -1) {
-            if (rank < previousRanks[previousRanks.length - 1]) {
-              context.report({
-                node: member,
-                messageId: 'incorrectOrder',
-                data: {
-                  name: getMemberName(member),
-                  rank: getLowestRank(previousRanks, rank, order),
-                },
-              });
-            } else {
-              previousRanks.push(rank);
-            }
+      if (orderConfig !== 'never') {
+        // Standardize config
+        let order = null;
+        let memberTypes;
+
+        if (Array.isArray(orderConfig)) {
+          memberTypes = orderConfig;
+        } else {
+          order = orderConfig.order;
+          memberTypes = orderConfig.memberTypes;
+        }
+
+        // Check order
+        if (Array.isArray(memberTypes)) {
+          const grouped = checkGroupSort(
+            members,
+            memberTypes,
+            supportsModifiers,
+          );
+
+          if (grouped === null) {
+            return;
           }
-        });
+
+          if (order === 'alphabetically') {
+            grouped.some(groupMember => !checkAlphaSort(groupMember));
+          }
+        } else if (order === 'alphabetically') {
+          checkAlphaSort(members);
+        }
       }
     }
 
diff --git a/packages/eslint-plugin/tests/rules/member-ordering.test.ts b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
index ddea73e8d1d..c64c57c4591 100644
--- a/packages/eslint-plugin/tests/rules/member-ordering.test.ts
+++ b/packages/eslint-plugin/tests/rules/member-ordering.test.ts
@@ -1,14 +1,16 @@
-// TODO - migrate this test to the rule
-/* eslint-disable @typescript-eslint/internal/plugin-test-formatting */
-
-import rule from '../../src/rules/member-ordering';
+import rule, {
+  defaultOrder,
+  MessageIds,
+  Options,
+} from '../../src/rules/member-ordering';
 import { RuleTester } from '../RuleTester';
+import { TSESLint } from '@typescript-eslint/experimental-utils';
 
 const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
 });
 
-ruleTester.run('member-ordering', rule, {
+const grouped: TSESLint.RunTests<MessageIds, Options> = {
   valid: [
     `
 // no accessibility === public
@@ -1339,7 +1341,7 @@ interface Foo {
             `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'method',
@@ -1372,7 +1374,7 @@ interface Foo {
       options: [{ default: ['signature', 'method', 'constructor', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -1381,7 +1383,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'field',
@@ -1390,7 +1392,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -1399,7 +1401,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -1408,7 +1410,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -1417,7 +1419,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -1426,7 +1428,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'field',
@@ -1435,7 +1437,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'Z',
             rank: 'field',
@@ -1470,7 +1472,7 @@ interface Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -1479,7 +1481,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'field',
@@ -1488,7 +1490,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -1497,7 +1499,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -1506,7 +1508,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -1515,7 +1517,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -1524,7 +1526,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'field',
@@ -1533,7 +1535,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'Z',
             rank: 'field',
@@ -1571,7 +1573,7 @@ interface Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -1580,7 +1582,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'field',
@@ -1589,7 +1591,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -1598,7 +1600,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -1607,7 +1609,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -1616,7 +1618,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -1625,7 +1627,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'field',
@@ -1634,7 +1636,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'Z',
             rank: 'field',
@@ -1671,7 +1673,7 @@ interface Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'B',
             rank: 'method',
@@ -1680,7 +1682,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'C',
             rank: 'method',
@@ -1689,7 +1691,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'D',
             rank: 'method',
@@ -1698,7 +1700,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'E',
             rank: 'method',
@@ -1707,7 +1709,7 @@ interface Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'F',
             rank: 'method',
@@ -1739,7 +1741,7 @@ type Foo = {
             `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'method',
@@ -1772,7 +1774,7 @@ type Foo = {
       options: [{ default: ['method', 'constructor', 'signature', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -1781,7 +1783,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'field',
@@ -1790,7 +1792,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -1799,7 +1801,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -1808,7 +1810,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -1817,7 +1819,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -1826,7 +1828,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'Z',
             rank: 'field',
@@ -1835,7 +1837,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'field',
@@ -1870,7 +1872,7 @@ type Foo = {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'signature',
@@ -1879,7 +1881,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'signature',
@@ -1888,7 +1890,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'signature',
@@ -1897,7 +1899,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'signature',
@@ -1906,7 +1908,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'signature',
@@ -1915,7 +1917,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'signature',
@@ -1924,7 +1926,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'signature',
@@ -1962,7 +1964,7 @@ type Foo = {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -1971,7 +1973,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'field',
@@ -1980,7 +1982,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -1989,7 +1991,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -1998,7 +2000,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -2007,7 +2009,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -2016,7 +2018,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'new',
             rank: 'field',
@@ -2025,7 +2027,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'Z',
             rank: 'field',
@@ -2062,7 +2064,7 @@ type Foo = {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'B',
             rank: 'method',
@@ -2071,7 +2073,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'C',
             rank: 'method',
@@ -2080,7 +2082,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'D',
             rank: 'method',
@@ -2089,7 +2091,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'E',
             rank: 'method',
@@ -2098,7 +2100,7 @@ type Foo = {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'F',
             rank: 'method',
@@ -2129,7 +2131,7 @@ class Foo {
             `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'public instance method',
@@ -2138,7 +2140,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'public instance method',
@@ -2147,7 +2149,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'public instance method',
@@ -2179,7 +2181,7 @@ class Foo {
       options: [{ default: ['field', 'constructor', 'method', 'signature'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'constructor',
@@ -2188,7 +2190,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'B',
             rank: 'constructor',
@@ -2197,7 +2199,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'C',
             rank: 'constructor',
@@ -2206,7 +2208,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'D',
             rank: 'constructor',
@@ -2215,7 +2217,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'E',
             rank: 'constructor',
@@ -2224,7 +2226,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'F',
             rank: 'constructor',
@@ -2255,7 +2257,7 @@ class Foo {
       options: [{ default: ['field', 'method'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'method',
@@ -2286,7 +2288,7 @@ class Foo {
       options: [{ default: ['method', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -2317,7 +2319,7 @@ class Foo {
       options: [{ classes: ['method', 'constructor', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -2326,7 +2328,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -2335,7 +2337,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -2344,7 +2346,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -2353,7 +2355,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'field',
@@ -2389,7 +2391,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -2398,7 +2400,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'field',
@@ -2407,7 +2409,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -2416,7 +2418,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -2425,7 +2427,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -2434,7 +2436,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -2443,7 +2445,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'field',
@@ -2486,7 +2488,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'private field',
@@ -2495,7 +2497,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'F',
             rank: 'protected field',
@@ -2539,7 +2541,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'public instance method',
@@ -2548,7 +2550,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'public field',
@@ -2589,7 +2591,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'method',
@@ -2632,7 +2634,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'private static method',
@@ -2641,7 +2643,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'private static method',
@@ -2676,7 +2678,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'protected static field',
@@ -2712,7 +2714,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'protected static field',
@@ -2742,7 +2744,7 @@ const foo = class Foo {
             `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'public instance method',
@@ -2751,7 +2753,7 @@ const foo = class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'public instance method',
@@ -2760,7 +2762,7 @@ const foo = class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'public instance method',
@@ -2792,7 +2794,7 @@ const foo = class {
       options: [{ default: ['signature', 'field', 'constructor', 'method'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'constructor',
@@ -2801,7 +2803,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'B',
             rank: 'constructor',
@@ -2810,7 +2812,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'C',
             rank: 'constructor',
@@ -2819,7 +2821,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'D',
             rank: 'constructor',
@@ -2828,7 +2830,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'E',
             rank: 'constructor',
@@ -2837,7 +2839,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'F',
             rank: 'constructor',
@@ -2869,7 +2871,7 @@ const foo = class {
       options: [{ default: ['field', 'method'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'method',
@@ -2900,7 +2902,7 @@ const foo = class {
       options: [{ default: ['method', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -2932,7 +2934,7 @@ const foo = class {
       options: [{ classExpressions: ['method', 'constructor', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -2941,7 +2943,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -2950,7 +2952,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -2959,7 +2961,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -2968,7 +2970,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'field',
@@ -3004,7 +3006,7 @@ const foo = class {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'field',
@@ -3013,7 +3015,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'field',
@@ -3022,7 +3024,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'I',
             rank: 'field',
@@ -3031,7 +3033,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -3040,7 +3042,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'field',
@@ -3049,7 +3051,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'field',
@@ -3058,7 +3060,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'field',
@@ -3101,7 +3103,7 @@ const foo = class {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'private field',
@@ -3110,7 +3112,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'F',
             rank: 'protected field',
@@ -3154,7 +3156,7 @@ const foo = class {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'public instance method',
@@ -3163,7 +3165,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'public field',
@@ -3204,7 +3206,7 @@ const foo = class {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'method',
@@ -3247,7 +3249,7 @@ const foo = class {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'G',
             rank: 'private static method',
@@ -3256,7 +3258,7 @@ const foo = class {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'H',
             rank: 'private static method',
@@ -3295,7 +3297,7 @@ const foo = class {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'L',
             rank: 'protected static field',
@@ -3331,7 +3333,7 @@ const foo = class {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'protected static field',
@@ -3341,7 +3343,6 @@ const foo = class {
         },
       ],
     },
-
     {
       code: `
 class Foo {
@@ -3354,7 +3355,7 @@ class Foo {
             `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'public instance method',
@@ -3363,7 +3364,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'constructor',
             rank: 'public instance method',
@@ -3372,7 +3373,7 @@ class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'Z',
             rank: 'public instance method',
@@ -3395,7 +3396,7 @@ class Foo {
       options: [{ default: ['method', 'constructor', 'field', 'signature'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'constructor',
@@ -3418,7 +3419,7 @@ class Foo {
       options: [{ default: ['method', 'constructor', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'K',
             rank: 'constructor',
@@ -3438,7 +3439,7 @@ interface Foo {
             `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'method',
@@ -3458,7 +3459,7 @@ type Foo = {
             `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'method',
@@ -3479,7 +3480,7 @@ type Foo = {
       options: [{ default: ['method', 'constructor', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'J',
             rank: 'field',
@@ -3498,7 +3499,7 @@ abstract class Foo {
           `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'B',
             rank: 'public abstract method',
@@ -3520,7 +3521,7 @@ abstract class Foo {
           `,
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'B',
             rank: 'public abstract field',
@@ -3541,7 +3542,7 @@ abstract class Foo {
       options: [{ default: ['method', 'constructor', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'C',
             rank: 'field',
@@ -3573,7 +3574,7 @@ class Foo {
       ],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'D',
             rank: 'signature',
@@ -3589,13 +3590,12 @@ abstract class Foo {
     abstract B: string;
     abstract A(): void;
     public C(): {};
-
 }
           `,
       options: [{ default: ['method', 'constructor', 'field'] }],
       errors: [
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'A',
             rank: 'field',
@@ -3604,7 +3604,7 @@ abstract class Foo {
           column: 5,
         },
         {
-          messageId: 'incorrectOrder',
+          messageId: 'incorrectGroupOrder',
           data: {
             name: 'C',
             rank: 'field',
@@ -3615,4 +3615,2255 @@ abstract class Foo {
       ],
     },
   ],
+};
+
+const sortedWithoutGroupingDefaultOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // default option + interface + multiple types
+    {
+      code: `
+interface Foo {
+  a(): Foo;
+  (): Foo;
+  b(): Foo;
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+    },
+
+    // default option + interface + lower/upper case
+    {
+      code: `
+interface Foo {
+  A : b;
+  a : b;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + interface + numbers
+    {
+      code: `
+interface Foo {
+  a1 : b;
+  aa : b;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + type literal + multiple types
+    {
+      code: `
+type Foo = {
+  a : b;
+  [a: string] : number;
+  b() : void;
+  new () : Bar;
+  () : Baz;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + type literal + lower/upper case
+    {
+      code: `
+type Foo = {
+  A : b;
+  a : b;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + type literal + numbers
+    {
+      code: `
+type Foo = {
+  a1 : b;
+  aa : b;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class + multiple types
+    {
+      code: `
+class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class + lower/upper case
+    {
+      code: `
+class Foo {
+  public static A : string;
+  public static a : string;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class + numbers
+    {
+      code: `
+class Foo {
+  public static a1 : string;
+  public static aa : string;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class expression + multiple types
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class expression + lower/upper case
+    {
+      code: `
+const foo = class Foo {
+  public static A : string;
+  public static a : string;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // default option + class expression + numbers
+    {
+      code: `
+const foo = class Foo {
+  public static a1 : string;
+  public static aa : string;
+}
+            `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+  ],
+  invalid: [
+    // default option + interface + wrong order
+    {
+      code: `
+interface Foo {
+  b() : void;
+  a : b;
+  [a: string] : number;
+  new () : Bar;
+  () : Baz;
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // default option + interface + wrong order (multiple)
+    {
+      code: `
+interface Foo {
+  c : string;
+  b : string;
+  a : string;
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // default option + type literal + wrong order
+    {
+      code: `
+type Foo = {
+  b() : void;
+  a : b;
+  [a: string] : number;
+  new () : Bar;
+  () : Baz;
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // default option + type literal + wrong order (multiple)
+    {
+      code: `
+type Foo = {
+  c : string;
+  b : string;
+  a : string;
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // default option + class + wrong order
+    {
+      code: `
+class Foo {
+  protected static b : string = "";
+  public static a : string;
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // default option + class + wrong order (multiple)
+    {
+      code: `
+class Foo {
+  public static c: string;
+  public static b: string;
+  public static a: string;
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // default option + class expression + wrong order
+    {
+      code: `
+const foo = class Foo {
+  protected static b : string = "";
+  public static a : string;
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // default option + class expression + wrong order (multiple)
+    {
+      code: `
+const foo = class Foo {
+  public static c: string;
+  public static b: string;
+  public static a: string;
+}
+          `,
+      options: [{ default: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithoutGroupingClassesOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // classes option + interface + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+  c : b;
+  new () : Bar;
+  b() : void;
+  () : Baz;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + interface + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  a : b;
+  A : b;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + interface + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  aa : b;
+  a1 : b;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + type literal + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+  c : b;
+  new () : Bar;
+  b() : void;
+  () : Baz;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + type literal + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  a : b;
+  A : b;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + type literal + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  aa : b;
+  a1 : b;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + class + multiple types
+    {
+      code: `
+class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + class + lower/upper case
+    {
+      code: `
+class Foo {
+  public static A : string;
+  public static a : string;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + class + numbers
+    {
+      code: `
+class Foo {
+  public static a1 : string;
+  public static aa : string;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + class expression + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+  constructor() {}
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + class expression + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  public static A : string;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+
+    // classes option + class expression + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static aa : string;
+  public static a1 : string;
+}
+            `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+    },
+  ],
+  invalid: [
+    // classes option + class + wrong order
+    {
+      code: `
+class Foo {
+  protected static b : string = "";
+  public static a : string;
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+          `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // classes option + class + wrong order (multiple)
+    {
+      code: `
+class Foo {
+  public static c: string;
+  public static b: string;
+  public static a: string;
+}
+          `,
+      options: [{ classes: { memberTypes: 'never', order: 'alphabetically' } }],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithoutGroupingClassExpressionsOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // classExpressions option + interface + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+  c : b;
+  new () : Bar;
+  b() : void;
+  () : Baz;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + interface + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  a : b;
+  A : b;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + interface + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  aa : b;
+  a1 : b;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + type literal + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+  c : b;
+  new () : Bar;
+  b() : void;
+  () : Baz;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + type literal + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  a : b;
+  A : b;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + type literal + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  aa : b;
+  a1 : b;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + class + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+  constructor() {}
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + class + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static a : string;
+  public static A : string;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + class + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static aa : string;
+  public static a1 : string;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + class expression + multiple types
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + class expression + lower/upper case
+    {
+      code: `
+const foo = class Foo {
+  public static A : string;
+  public static a : string;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // classExpressions option + class expression + numbers
+    {
+      code: `
+const foo = class Foo {
+  public static a1 : string;
+  public static aa : string;
+}
+            `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+  ],
+  invalid: [
+    // classExpressions option + class expression + wrong order
+    {
+      code: `
+const foo = class Foo {
+  protected static b : string = "";
+  public static a : string;
+  private static c : string = "";
+  constructor() {}
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+}
+          `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // classExpressions option + class expression + wrong order (multiple)
+    {
+      code: `
+const foo = class Foo {
+  public static c: string;
+  public static b: string;
+  public static a: string;
+}
+          `,
+      options: [
+        { classExpressions: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithoutGroupingInterfacesOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // interfaces option + interface + multiple types
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+  a : b;
+  b() : void;
+  new () : Bar;
+  () : Baz;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + interface + lower/upper case
+    {
+      code: `
+interface Foo {
+  A : b;
+  a : b;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + interface + numbers
+    {
+      code: `
+interface Foo {
+  a1 : b;
+  aa : b;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + type literal + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+  c : b;
+  new () : Bar;
+  b() : void;
+  () : Baz;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + type literal + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  a : b;
+  A : b;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + type literal + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+type Foo = {
+  aa : b;
+  a1 : b;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + class + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+  constructor() {}
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + class + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static a : string;
+  public static A : string;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + class + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static aa : string;
+  public static a1 : string;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + class expression + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+  constructor() {}
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + class expression + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  public static A : string;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // interfaces option + class expression + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static aa : string;
+  public static a1 : string;
+}
+            `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+  ],
+  invalid: [
+    // interfaces option + interface + wrong order
+    {
+      code: `
+interface Foo {
+  b() : void;
+  a : b;
+  [a: string] : number;
+  new () : Bar;
+  () : Baz;
+}
+          `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // interfaces option + interface + wrong order (multiple)
+    {
+      code: `
+interface Foo {
+  c : string;
+  b : string;
+  a : string;
+}
+          `,
+      options: [
+        { interfaces: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithoutGroupingTypeLiteralsOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // typeLiterals option + interface + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+  c : b;
+  new () : Bar;
+  b() : void;
+  () : Baz;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + interface + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  a : b;
+  A : b;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + interface + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+interface Foo {
+  aa : b;
+  a1 : b;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + type literal + multiple types
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+  a : b;
+  b() : void;
+  new () : Bar;
+  () : Baz;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + type literal + lower/upper case
+    {
+      code: `
+type Foo = {
+  A : b;
+  a : b;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + type literal + numbers
+    {
+      code: `
+type Foo = {
+  a1 : b;
+  aa : b;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + class + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+  constructor() {}
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + class + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static a : string;
+  public static A : string;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + class + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+class Foo {
+  public static aa : string;
+  public static a1 : string;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + class expression + multiple types --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  protected static b : string = "";
+  private static c : string = "";
+  public d : string = "";
+  protected e : string = "";
+  private f : string = "";
+  constructor() {}
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + class expression + lower/upper case --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static a : string;
+  public static A : string;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+
+    // typeLiterals option + class expression + numbers --> Only member group order is checked (default config)
+    {
+      code: `
+const foo = class Foo {
+  public static aa : string;
+  public static a1 : string;
+}
+            `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+    },
+  ],
+  invalid: [
+    // typeLiterals option + type literal + wrong order
+    {
+      code: `
+type Foo = {
+  b() : void;
+  a : b;
+  [a: string] : number;
+  new () : Bar;
+  () : Baz;
+}
+          `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+
+    // typeLiterals option + type literal + wrong order (multiple)
+    {
+      code: `
+type Foo = {
+  c : string;
+  b : string;
+  a : string;
+}
+          `,
+      options: [
+        { typeLiterals: { memberTypes: 'never', order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'b',
+            beforeMember: 'c',
+          },
+        },
+        {
+          messageId: 'incorrectOrder',
+          data: {
+            member: 'a',
+            beforeMember: 'b',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithGroupingDefaultOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // default option + interface + default order + alphabetically
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  new () : Bar;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  () : Baz;
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+    },
+
+    // default option + interface + custom order + alphabetically
+    {
+      code: `
+interface Foo {
+  new () : Bar;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  a : x;
+  b : x;
+  c : x;
+
+  [a: string] : number;
+  () : Baz;
+}
+            `,
+      options: [
+        {
+          default: {
+            memberTypes: ['constructor', 'method', 'field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // default option + type literal + default order + alphabetically
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  new () : Bar;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  () : Baz;
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+    },
+
+    // default option + type literal + custom order + alphabetically
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  new () : Bar;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  a : x;
+  b : x;
+  c : x;
+
+  () : Baz;
+}
+            `,
+      options: [
+        {
+          default: {
+            memberTypes: ['constructor', 'method', 'field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // default option + class + default order + alphabetically
+    {
+      code: `
+class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+    },
+
+    // default option + class + custom order + alphabetically
+    {
+      code: `
+class Foo {
+  constructor() {}
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+}
+            `,
+      options: [
+        {
+          default: {
+            memberTypes: ['constructor', 'instance-field', 'static-field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // default option + class expression + default order + alphabetically
+    {
+      code: `
+const foo = class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+    },
+
+    // default option + class expression + custom order + alphabetically
+    {
+      code: `
+const foo = class Foo {
+  constructor() {}
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+}
+            `,
+      options: [
+        {
+          default: {
+            memberTypes: ['constructor', 'instance-field', 'static-field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+  ],
+  invalid: [
+    // default option + interface + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+
+  new () : Bar;
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+        },
+      ],
+    },
+
+    // default option + type literal + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+
+  new () : Bar;
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+        },
+      ],
+    },
+
+    // default option + class + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+class Foo {
+  public static c: string = "";
+  public static b: string = "";
+  public static a: string;
+
+  constructor() {}
+
+  public d: string = "";
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'd',
+            rank: 'public constructor',
+          },
+        },
+      ],
+    },
+
+    // default option + class expression + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+const foo = class Foo {
+  public static c: string = "";
+  public static b: string = "";
+  public static a: string;
+
+  constructor() {}
+
+  public d: string = "";
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'd',
+            rank: 'public constructor',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithGroupingClassesOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // classes option + interface + alphabetically --> Default order applies
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+
+  c : x;
+  b : x;
+  a : x;
+
+  new () : Bar;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+}
+            `,
+      options: [{ classes: { order: 'alphabetically' } }],
+    },
+
+    // classes option + type literal + alphabetically --> Default order applies
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  c : x;
+  b : x;
+  a : x;
+
+  new () : Bar;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+}
+            `,
+      options: [{ classes: { order: 'alphabetically' } }],
+    },
+
+    // classes option + class + default order + alphabetically
+    {
+      code: `
+class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [
+        { classes: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+    },
+
+    // classes option + class + custom order + alphabetically
+    {
+      code: `
+class Foo {
+  constructor() {}
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+}
+            `,
+      options: [
+        {
+          classes: {
+            memberTypes: ['constructor', 'instance-field', 'static-field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // classes option + class expression + alphabetically --> Default order applies
+    {
+      code: `
+const foo = class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [{ classes: { order: 'alphabetically' } }],
+    },
+  ],
+  invalid: [
+    // default option + class + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+class Foo {
+  public static c: string = "";
+  public static b: string = "";
+  public static a: string;
+
+  constructor() {}
+
+  public d: string = "";
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'd',
+            rank: 'public constructor',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithGroupingClassExpressionsOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // classExpressions option + interface + alphabetically --> Default order applies
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+
+  c : x;
+  b : x;
+  a : x;
+
+  new () : Bar;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+}
+            `,
+      options: [{ classExpressions: { order: 'alphabetically' } }],
+    },
+
+    // classExpressions option + type literal + alphabetically --> Default order applies
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  c : x;
+  b : x;
+  a : x;
+
+  new () : Bar;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+}
+            `,
+      options: [{ classExpressions: { order: 'alphabetically' } }],
+    },
+
+    // classExpressions option + class + alphabetically --> Default order applies
+    {
+      code: `
+class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [{ classExpressions: { order: 'alphabetically' } }],
+    },
+
+    // classExpressions option + class expression + default order + alphabetically
+    {
+      code: `
+const foo = class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [
+        {
+          classExpressions: {
+            memberTypes: defaultOrder,
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // classExpressions option + class expression + custom order + alphabetically
+    {
+      code: `
+const foo = class Foo {
+  constructor() {}
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+}
+            `,
+      options: [
+        {
+          classExpressions: {
+            memberTypes: ['constructor', 'instance-field', 'static-field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+  ],
+  invalid: [
+    // default option + class expression + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+const foo = class Foo {
+  public static c: string = "";
+  public static b: string = "";
+  public static a: string;
+
+  constructor() {}
+
+  public d: string = "";
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'd',
+            rank: 'public constructor',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithGroupingInterfacesOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // interfaces option + interface + default order + alphabetically
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  new () : Bar;
+
+  () : Baz;
+}
+            `,
+      options: [
+        {
+          interfaces: {
+            memberTypes: ['signature', 'field', 'method', 'constructor'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // interfaces option + interface + custom order + alphabetically
+    {
+      code: `
+interface Foo {
+  new () : Bar;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  a : x;
+  b : x;
+  c : x;
+
+  [a: string] : number;
+  () : Baz;
+}
+            `,
+      options: [
+        {
+          interfaces: {
+            memberTypes: ['constructor', 'method', 'field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // interfaces option + type literal + alphabetically --> Default order applies
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  c : x;
+  b : x;
+  a : x;
+
+  new () : Bar;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+}
+            `,
+      options: [{ interfaces: { order: 'alphabetically' } }],
+    },
+
+    // interfaces option + class + alphabetically --> Default order applies
+    {
+      code: `
+class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [{ interfaces: { order: 'alphabetically' } }],
+    },
+
+    // interfaces option + class expression + alphabetically --> Default order applies
+    {
+      code: `
+const foo = class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [{ interfaces: { order: 'alphabetically' } }],
+    },
+  ],
+  invalid: [
+    // default option + interface + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+
+  new () : Bar;
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithGroupingTypeLiteralsOption: TSESLint.RunTests<
+  MessageIds,
+  Options
+> = {
+  valid: [
+    // typeLiterals option + interface + alphabetically --> Default order applies
+    {
+      code: `
+interface Foo {
+  [a: string] : number;
+
+  c : x;
+  b : x;
+  a : x;
+
+  new () : Bar;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+}
+            `,
+      options: [{ typeLiterals: { order: 'alphabetically' } }],
+    },
+
+    // typeLiterals option + type literal + default order + alphabetically
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  new () : Bar;
+
+  () : Baz;
+}
+            `,
+      options: [
+        {
+          typeLiterals: {
+            memberTypes: ['signature', 'field', 'method', 'constructor'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // typeLiterals option + type literal + custom order + alphabetically
+    {
+      code: `
+type Foo = {
+  new () : Bar;
+
+  a() : void;
+  b() : void;
+  c() : void;
+
+  a : x;
+  b : x;
+  c : x;
+
+  [a: string] : number;
+  () : Baz;
+}
+            `,
+      options: [
+        {
+          typeLiterals: {
+            memberTypes: ['constructor', 'method', 'field'],
+            order: 'alphabetically',
+          },
+        },
+      ],
+    },
+
+    // typeLiterals option + class + alphabetically --> Default order applies
+    {
+      code: `
+class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [{ typeLiterals: { order: 'alphabetically' } }],
+    },
+
+    // typeLiterals option + class expression + alphabetically --> Default order applies
+    {
+      code: `
+const foo = class Foo {
+  public static a: string;
+  protected static b: string = "";
+  private static c: string = "";
+
+  public d: string = "";
+  protected e: string = "";
+  private f: string = "";
+
+  constructor() {}
+}
+            `,
+      options: [{ typeLiterals: { order: 'alphabetically' } }],
+    },
+  ],
+  invalid: [
+    // default option + type literal + wrong order within group and wrong group order + alphabetically
+    {
+      code: `
+type Foo = {
+  [a: string] : number;
+
+  a : x;
+  b : x;
+  c : x;
+
+  c() : void;
+  b() : void;
+  a() : void;
+
+  () : Baz;
+
+  new () : Bar;
+}
+            `,
+      options: [
+        { default: { memberTypes: defaultOrder, order: 'alphabetically' } },
+      ],
+      errors: [
+        {
+          messageId: 'incorrectGroupOrder',
+          data: {
+            name: 'new',
+            rank: 'method',
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const sortedWithoutGrouping = {
+  valid: [
+    ...sortedWithoutGroupingDefaultOption.valid,
+    ...sortedWithoutGroupingClassesOption.valid,
+    ...sortedWithoutGroupingClassExpressionsOption.valid,
+    ...sortedWithoutGroupingInterfacesOption.valid,
+    ...sortedWithoutGroupingTypeLiteralsOption.valid,
+  ],
+  invalid: [
+    ...sortedWithoutGroupingDefaultOption.invalid,
+    ...sortedWithoutGroupingClassesOption.invalid,
+    ...sortedWithoutGroupingClassExpressionsOption.invalid,
+    ...sortedWithoutGroupingInterfacesOption.invalid,
+    ...sortedWithoutGroupingTypeLiteralsOption.invalid,
+  ],
+};
+
+const sortedWithGrouping = {
+  valid: [
+    ...sortedWithGroupingDefaultOption.valid,
+    ...sortedWithGroupingClassesOption.valid,
+    ...sortedWithGroupingClassExpressionsOption.valid,
+    ...sortedWithGroupingInterfacesOption.valid,
+    ...sortedWithGroupingTypeLiteralsOption.valid,
+  ],
+  invalid: [
+    ...sortedWithGroupingDefaultOption.invalid,
+    ...sortedWithGroupingClassesOption.invalid,
+    ...sortedWithGroupingClassExpressionsOption.invalid,
+    ...sortedWithGroupingInterfacesOption.invalid,
+    ...sortedWithGroupingTypeLiteralsOption.invalid,
+  ],
+};
+
+ruleTester.run('member-ordering', rule, {
+  valid: [
+    ...grouped.valid,
+    ...sortedWithoutGrouping.valid,
+    ...sortedWithGrouping.valid,
+  ],
+  invalid: [
+    ...grouped.invalid,
+    ...sortedWithoutGrouping.invalid,
+    ...sortedWithGrouping.invalid,
+  ],
 });
diff --git a/packages/typescript-estree/src/ts-estree/ts-estree.ts b/packages/typescript-estree/src/ts-estree/ts-estree.ts
index cbf7787c805..24486b974b3 100644
--- a/packages/typescript-estree/src/ts-estree/ts-estree.ts
+++ b/packages/typescript-estree/src/ts-estree/ts-estree.ts
@@ -308,11 +308,9 @@ export type BindingPattern = ArrayPattern | ObjectPattern;
 export type BindingName = BindingPattern | Identifier;
 export type ClassElement =
   | ClassProperty
-  | FunctionExpression
   | MethodDefinition
   | TSAbstractClassProperty
   | TSAbstractMethodDefinition
-  | TSEmptyBodyFunctionExpression
   | TSIndexSignature;
 export type ClassProperty =
   | ClassPropertyComputedName

From ab8572e30e14ebda91c8437be5ee35e7dc9add2e Mon Sep 17 00:00:00 2001
From: Stan Wohlwend <n2d4xc@gmail.com>
Date: Fri, 3 Apr 2020 06:34:13 +0200
Subject: [PATCH 20/36] =?UTF-8?q?fix(eslint-plugin):=20no-explicit-any=20c?=
 =?UTF-8?q?onstructor=20functions=20(&=20mo=E2=80=A6=20(#1711)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../docs/rules/no-explicit-any.md             |  76 +++---
 .../src/rules/no-explicit-any.ts              |  19 +-
 .../tests/rules/no-explicit-any.test.ts       | 225 ++++++++++++++++--
 3 files changed, 242 insertions(+), 78 deletions(-)

diff --git a/packages/eslint-plugin/docs/rules/no-explicit-any.md b/packages/eslint-plugin/docs/rules/no-explicit-any.md
index 0c271392349..c440d3bdc60 100644
--- a/packages/eslint-plugin/docs/rules/no-explicit-any.md
+++ b/packages/eslint-plugin/docs/rules/no-explicit-any.md
@@ -119,30 +119,23 @@ function foo2(...args: readonly any[]): void {}
 function foo3(...args: Array<any>): void {}
 function foo4(...args: ReadonlyArray<any>): void {}
 
-const bar1 = (...args: any[]): void {}
-const bar2 = (...args: readonly any[]): void {}
-const bar3 = (...args: Array<any>): void {}
-const bar4 = (...args: ReadonlyArray<any>): void {}
+declare function bar(...args: any[]): void;
 
-const baz1 = function (...args: any[]) {}
-const baz2 = function (...args: readonly any[]) {}
-const baz3 = function (...args: Array<any>) {}
-const baz4 = function (...args: ReadonlyArray<any>) {}
+const baz = (...args: any[]) => {};
+const qux = function(...args: any[]) {};
 
-interface Qux1 { (...args: any[]): void; }
-interface Qux2 { (...args: readonly any[]): void; }
-interface Qux3 { (...args: Array<any>): void; }
-interface Qux4 { (...args: ReadonlyArray<any>): void; }
+type Quux = (...args: any[]) => void;
+type Quuz = new (...args: any[]) => void;
 
-function quux1(fn: (...args: any[]) => void): void {}
-function quux2(fn: (...args: readonly any[]) => void): void {}
-function quux3(fn: (...args: Array<any>) => void): void {}
-function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}
-
-function quuz1(): ((...args: any[]) => void) {}
-function quuz2(): ((...args: readonly any[]) => void) {}
-function quuz3(): ((...args: Array<any>) => void) {}
-function quuz4(): ((...args: ReadonlyArray<any>) => void) {}
+interface Grault {
+  (...args: any[]): void;
+}
+interface Corge {
+  new (...args: any[]): void;
+}
+interface Garply {
+  f(...args: any[]): void;
+}
 ```
 
 Examples of **correct** code for the `{ "ignoreRestArgs": true }` option:
@@ -155,30 +148,23 @@ function foo2(...args: readonly any[]): void {}
 function foo3(...args: Array<any>): void {}
 function foo4(...args: ReadonlyArray<any>): void {}
 
-const bar1 = (...args: any[]): void {}
-const bar2 = (...args: readonly any[]): void {}
-const bar3 = (...args: Array<any>): void {}
-const bar4 = (...args: ReadonlyArray<any>): void {}
-
-const baz1 = function (...args: any[]) {}
-const baz2 = function (...args: readonly any[]) {}
-const baz3 = function (...args: Array<any>) {}
-const baz4 = function (...args: ReadonlyArray<any>) {}
-
-interface Qux1 { (...args: any[]): void; }
-interface Qux2 { (...args: readonly any[]): void; }
-interface Qux3 { (...args: Array<any>): void; }
-interface Qux4 { (...args: ReadonlyArray<any>): void; }
-
-function quux1(fn: (...args: any[]) => void): void {}
-function quux2(fn: (...args: readonly any[]) => void): void {}
-function quux3(fn: (...args: Array<any>) => void): void {}
-function quux4(fn: (...args: ReadonlyArray<any>) => void): void {}
-
-function quuz1(): ((...args: any[]) => void) {}
-function quuz2(): ((...args: readonly any[]) => void) {}
-function quuz3(): ((...args: Array<any>) => void) {}
-function quuz4(): ((...args: ReadonlyArray<any>) => void) {}
+declare function bar(...args: any[]): void;
+
+const baz = (...args: any[]) => {};
+const qux = function(...args: any[]) {};
+
+type Quux = (...args: any[]) => void;
+type Quuz = new (...args: any[]) => void;
+
+interface Grault {
+  (...args: any[]): void;
+}
+interface Corge {
+  new (...args: any[]): void;
+}
+interface Garply {
+  f(...args: any[]): void;
+}
 ```
 
 ## When Not To Use It
diff --git a/packages/eslint-plugin/src/rules/no-explicit-any.ts b/packages/eslint-plugin/src/rules/no-explicit-any.ts
index 91765c40e26..795dae01725 100644
--- a/packages/eslint-plugin/src/rules/no-explicit-any.ts
+++ b/packages/eslint-plugin/src/rules/no-explicit-any.ts
@@ -53,18 +53,23 @@ export default util.createRule<Options, MessageIds>({
   ],
   create(context, [{ ignoreRestArgs, fixToUnknown }]) {
     /**
-     * Checks if the node is an arrow function, function declaration or function expression
+     * Checks if the node is an arrow function, function/constructor declaration or function expression
      * @param node the node to be validated.
-     * @returns true if the node is an arrow function, function declaration, function expression, function type, or call signature
+     * @returns true if the node is any kind of function declaration or expression
      * @private
      */
     function isNodeValidFunction(node: TSESTree.Node): boolean {
       return [
-        AST_NODE_TYPES.ArrowFunctionExpression,
-        AST_NODE_TYPES.FunctionDeclaration,
-        AST_NODE_TYPES.FunctionExpression,
-        AST_NODE_TYPES.TSFunctionType,
-        AST_NODE_TYPES.TSCallSignatureDeclaration,
+        AST_NODE_TYPES.ArrowFunctionExpression, // const x = (...args: any[]) => {};
+        AST_NODE_TYPES.FunctionDeclaration, // function f(...args: any[]) {}
+        AST_NODE_TYPES.FunctionExpression, // const x = function(...args: any[]) {};
+        AST_NODE_TYPES.TSEmptyBodyFunctionExpression, // declare class A { f(...args: any[]): unknown; }
+        AST_NODE_TYPES.TSFunctionType, // type T = (...args: any[]) => unknown;
+        AST_NODE_TYPES.TSConstructorType, // type T = new (...args: any[]) => unknown
+        AST_NODE_TYPES.TSCallSignatureDeclaration, // type T = {(...args: any[]): unknown};
+        AST_NODE_TYPES.TSConstructSignatureDeclaration, // type T = {new (...args: any[]): unknown};
+        AST_NODE_TYPES.TSMethodSignature, // type T = {f(...args: any[]): unknown};
+        AST_NODE_TYPES.TSDeclareFunction, // declare function _8(...args: any[]): unknown;
       ].includes(node.type);
     }
 
diff --git a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
index dde8b938175..1a5b9c5778c 100644
--- a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
@@ -255,6 +255,118 @@ interface Qux4 {
       code: 'function quuz4(): (...args: ReadonlyArray<any>) => void {}',
       options: [{ ignoreRestArgs: true }],
     },
+    {
+      code: 'type Fred1 = (...args: any[]) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'type Fred2 = (...args: readonly any[]) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'type Fred3 = (...args: Array<any>) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'type Fred4 = (...args: ReadonlyArray<any>) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'type Corge1 = new (...args: any[]) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'type Corge2 = new (...args: readonly any[]) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'type Corge3 = new (...args: Array<any>) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'type Corge4 = new (...args: ReadonlyArray<any>) => void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Grault1 {
+  new (...args: any[]): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Grault2 {
+  new (...args: readonly any[]): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Grault3 {
+  new (...args: Array<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Grault4 {
+  new (...args: ReadonlyArray<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Garply1 {
+  f(...args: any[]): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Garply2 {
+  f(...args: readonly any[]): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Garply3 {
+  f(...args: Array<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: `
+interface Garply4 {
+  f(...args: ReadonlyArray<any>): void;
+}
+      `,
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'declare function waldo1(...args: any[]): void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'declare function waldo2(...args: readonly any[]): void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'declare function waldo3(...args: Array<any>): void;',
+      options: [{ ignoreRestArgs: true }],
+    },
+    {
+      code: 'declare function waldo4(...args: ReadonlyArray<any>): void;',
+      options: [{ ignoreRestArgs: true }],
+    },
   ],
   invalid: ([
     {
@@ -737,7 +849,7 @@ type obj = {
       ],
     },
     {
-      code: `class Foo<t = any> extends Bar<any> {}`,
+      code: 'class Foo<t = any> extends Bar<any> {}',
       errors: [
         {
           messageId: 'unexpectedAny',
@@ -746,11 +858,11 @@ type obj = {
           suggestions: [
             {
               messageId: 'suggestUnknown',
-              output: `class Foo<t = unknown> extends Bar<any> {}`,
+              output: 'class Foo<t = unknown> extends Bar<any> {}',
             },
             {
               messageId: 'suggestNever',
-              output: `class Foo<t = never> extends Bar<any> {}`,
+              output: 'class Foo<t = never> extends Bar<any> {}',
             },
           ],
         },
@@ -761,18 +873,18 @@ type obj = {
           suggestions: [
             {
               messageId: 'suggestUnknown',
-              output: `class Foo<t = any> extends Bar<unknown> {}`,
+              output: 'class Foo<t = any> extends Bar<unknown> {}',
             },
             {
               messageId: 'suggestNever',
-              output: `class Foo<t = any> extends Bar<never> {}`,
+              output: 'class Foo<t = any> extends Bar<never> {}',
             },
           ],
         },
       ],
     },
     {
-      code: `abstract class Foo<t = any> extends Bar<any> {}`,
+      code: 'abstract class Foo<t = any> extends Bar<any> {}',
       errors: [
         {
           messageId: 'unexpectedAny',
@@ -781,11 +893,11 @@ type obj = {
           suggestions: [
             {
               messageId: 'suggestUnknown',
-              output: `abstract class Foo<t = unknown> extends Bar<any> {}`,
+              output: 'abstract class Foo<t = unknown> extends Bar<any> {}',
             },
             {
               messageId: 'suggestNever',
-              output: `abstract class Foo<t = never> extends Bar<any> {}`,
+              output: 'abstract class Foo<t = never> extends Bar<any> {}',
             },
           ],
         },
@@ -796,18 +908,18 @@ type obj = {
           suggestions: [
             {
               messageId: 'suggestUnknown',
-              output: `abstract class Foo<t = any> extends Bar<unknown> {}`,
+              output: 'abstract class Foo<t = any> extends Bar<unknown> {}',
             },
             {
               messageId: 'suggestNever',
-              output: `abstract class Foo<t = any> extends Bar<never> {}`,
+              output: 'abstract class Foo<t = any> extends Bar<never> {}',
             },
           ],
         },
       ],
     },
     {
-      code: `abstract class Foo<t = any> implements Bar<any>, Baz<any> {}`,
+      code: 'abstract class Foo<t = any> implements Bar<any>, Baz<any> {}',
       errors: [
         {
           messageId: 'unexpectedAny',
@@ -816,11 +928,13 @@ type obj = {
           suggestions: [
             {
               messageId: 'suggestUnknown',
-              output: `abstract class Foo<t = unknown> implements Bar<any>, Baz<any> {}`,
+              output:
+                'abstract class Foo<t = unknown> implements Bar<any>, Baz<any> {}',
             },
             {
               messageId: 'suggestNever',
-              output: `abstract class Foo<t = never> implements Bar<any>, Baz<any> {}`,
+              output:
+                'abstract class Foo<t = never> implements Bar<any>, Baz<any> {}',
             },
           ],
         },
@@ -831,11 +945,13 @@ type obj = {
           suggestions: [
             {
               messageId: 'suggestUnknown',
-              output: `abstract class Foo<t = any> implements Bar<unknown>, Baz<any> {}`,
+              output:
+                'abstract class Foo<t = any> implements Bar<unknown>, Baz<any> {}',
             },
             {
               messageId: 'suggestNever',
-              output: `abstract class Foo<t = any> implements Bar<never>, Baz<any> {}`,
+              output:
+                'abstract class Foo<t = any> implements Bar<never>, Baz<any> {}',
             },
           ],
         },
@@ -846,18 +962,20 @@ type obj = {
           suggestions: [
             {
               messageId: 'suggestUnknown',
-              output: `abstract class Foo<t = any> implements Bar<any>, Baz<unknown> {}`,
+              output:
+                'abstract class Foo<t = any> implements Bar<any>, Baz<unknown> {}',
             },
             {
               messageId: 'suggestNever',
-              output: `abstract class Foo<t = any> implements Bar<any>, Baz<never> {}`,
+              output:
+                'abstract class Foo<t = any> implements Bar<any>, Baz<never> {}',
             },
           ],
         },
       ],
     },
     {
-      code: `new Foo<any>()`,
+      code: 'new Foo<any>()',
       errors: [
         {
           messageId: 'unexpectedAny',
@@ -867,7 +985,7 @@ type obj = {
       ],
     },
     {
-      code: `Foo<any>()`,
+      code: 'Foo<any>()',
       errors: [
         {
           messageId: 'unexpectedAny',
@@ -943,7 +1061,7 @@ const test = <T extends Partial<never>>() => {};
       ],
     },
     {
-      code: `type Any = any;`,
+      code: 'type Any = any;',
       options: [{ ignoreRestArgs: true }],
       errors: [
         {
@@ -954,7 +1072,7 @@ const test = <T extends Partial<never>>() => {};
       ],
     },
     {
-      code: `function foo5(...args: any) {}`,
+      code: 'function foo5(...args: any) {}',
       options: [{ ignoreRestArgs: true }],
       errors: [
         {
@@ -965,7 +1083,7 @@ const test = <T extends Partial<never>>() => {};
       ],
     },
     {
-      code: `const bar5 = function (...args: any) {}`,
+      code: 'const bar5 = function (...args: any) {}',
       options: [{ ignoreRestArgs: true }],
       errors: [
         {
@@ -976,7 +1094,7 @@ const test = <T extends Partial<never>>() => {};
       ],
     },
     {
-      code: `const baz5 = (...args: any) => {}`,
+      code: 'const baz5 = (...args: any) => {}',
       options: [{ ignoreRestArgs: true }],
       errors: [
         {
@@ -987,7 +1105,7 @@ const test = <T extends Partial<never>>() => {};
       ],
     },
     {
-      code: `interface Qux5 { (...args: any): void; }`,
+      code: 'interface Qux5 { (...args: any): void; }',
       options: [{ ignoreRestArgs: true }],
       errors: [
         {
@@ -998,7 +1116,7 @@ const test = <T extends Partial<never>>() => {};
       ],
     },
     {
-      code: `function quux5(fn: (...args: any) => void): void {}`,
+      code: 'function quux5(fn: (...args: any) => void): void {}',
       options: [{ ignoreRestArgs: true }],
       errors: [
         {
@@ -1009,7 +1127,7 @@ const test = <T extends Partial<never>>() => {};
       ],
     },
     {
-      code: `function quuz5(): ((...args: any) => void) {}`,
+      code: 'function quuz5(): ((...args: any) => void) {}',
       options: [{ ignoreRestArgs: true }],
       errors: [
         {
@@ -1019,6 +1137,61 @@ const test = <T extends Partial<never>>() => {};
         },
       ],
     },
+    {
+      code: 'type Fred5 = (...args: any) => void;',
+      options: [{ ignoreRestArgs: true }],
+      errors: [
+        {
+          messageId: 'unexpectedAny',
+          line: 1,
+          column: 24,
+        },
+      ],
+    },
+    {
+      code: 'type Corge5 = new (...args: any) => void;',
+      options: [{ ignoreRestArgs: true }],
+      errors: [
+        {
+          messageId: 'unexpectedAny',
+          line: 1,
+          column: 29,
+        },
+      ],
+    },
+    {
+      code: 'interface Grault5 { new (...args: any): void; }',
+      options: [{ ignoreRestArgs: true }],
+      errors: [
+        {
+          messageId: 'unexpectedAny',
+          line: 1,
+          column: 35,
+        },
+      ],
+    },
+    {
+      code: 'interface Garply5 { f(...args: any): void; }',
+      options: [{ ignoreRestArgs: true }],
+      errors: [
+        {
+          messageId: 'unexpectedAny',
+          line: 1,
+          column: 32,
+        },
+      ],
+    },
+    {
+      code: 'declare function waldo5(...args: any): void;',
+      options: [{ ignoreRestArgs: true }],
+      errors: [
+        {
+          messageId: 'unexpectedAny',
+          line: 1,
+          column: 34,
+        },
+      ],
+    },
   ] as InvalidTestCase[]).reduce<InvalidTestCase[]>((acc, testCase) => {
     const suggestions = (code: string): SuggestionOutput[] => [
       {

From d304a05c558256b0771337bdb42e846da340f2ab Mon Sep 17 00:00:00 2001
From: cherryblossom000 <31467609+cherryblossom000@users.noreply.github.com>
Date: Sat, 4 Apr 2020 03:24:27 +1100
Subject: [PATCH 21/36] docs(eslint-plugin): [no-type-alias] fix typo (#1840)

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

diff --git a/packages/eslint-plugin/docs/rules/no-type-alias.md b/packages/eslint-plugin/docs/rules/no-type-alias.md
index 9d7f1d47744..5b720b2f331 100644
--- a/packages/eslint-plugin/docs/rules/no-type-alias.md
+++ b/packages/eslint-plugin/docs/rules/no-type-alias.md
@@ -69,7 +69,7 @@ On the other hand, using a type alias as an interface can limit your ability to:
 - Debug your code: interfaces create a new name, so is easy to identify the base type of an object
   while debugging the application.
 
-Finally, mapping types is an advance technique, leaving it open can quickly become a pain point
+Finally, mapping types is an advanced technique and leaving it open can quickly become a pain point
 in your application.
 
 ## Rule Details

From ead0171a32f57eb7170dd51aa032e2edb3256995 Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Fri, 3 Apr 2020 09:56:24 -0700
Subject: [PATCH 22/36] chore: fix issue template link (#1842)

---
 .github/ISSUE_TEMPLATE/eslint-plugin-tslint.md     | 2 +-
 .github/ISSUE_TEMPLATE/eslint-plugin-typescript.md | 2 +-
 .github/ISSUE_TEMPLATE/typescript-eslint-parser.md | 2 +-
 .github/ISSUE_TEMPLATE/typescript-eslint-utils.md  | 2 +-
 .github/ISSUE_TEMPLATE/typescript-estree.md        | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/eslint-plugin-tslint.md b/.github/ISSUE_TEMPLATE/eslint-plugin-tslint.md
index b94f19fb5b8..e999830e4f1 100644
--- a/.github/ISSUE_TEMPLATE/eslint-plugin-tslint.md
+++ b/.github/ISSUE_TEMPLATE/eslint-plugin-tslint.md
@@ -15,7 +15,7 @@ The more relevant information you can include, the faster we can find the issue
 
 <!--
 Make sure you read through our FAQ before posting.
-https://github.com/typescript-eslint/typescript-eslint/blob/issue-template-update/docs/getting-started/linting/FAQ.md
+https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md
 -->
 
 **Repro**
diff --git a/.github/ISSUE_TEMPLATE/eslint-plugin-typescript.md b/.github/ISSUE_TEMPLATE/eslint-plugin-typescript.md
index 3c0fb548f13..b9ab13f9249 100644
--- a/.github/ISSUE_TEMPLATE/eslint-plugin-typescript.md
+++ b/.github/ISSUE_TEMPLATE/eslint-plugin-typescript.md
@@ -28,7 +28,7 @@ Are you opening an issue because the rule you're trying to use is not found?
 
 <!--
 Make sure you read through our FAQ before posting.
-https://github.com/typescript-eslint/typescript-eslint/blob/issue-template-update/docs/getting-started/linting/FAQ.md
+https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md
 -->
 
 **Repro**
diff --git a/.github/ISSUE_TEMPLATE/typescript-eslint-parser.md b/.github/ISSUE_TEMPLATE/typescript-eslint-parser.md
index aaa4bfd356c..ca8d245b263 100644
--- a/.github/ISSUE_TEMPLATE/typescript-eslint-parser.md
+++ b/.github/ISSUE_TEMPLATE/typescript-eslint-parser.md
@@ -15,7 +15,7 @@ The more relevant information you can include, the faster we can find the issue
 
 <!--
 Make sure you read through our FAQ before posting.
-https://github.com/typescript-eslint/typescript-eslint/blob/issue-template-update/docs/getting-started/linting/FAQ.md
+https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md
 -->
 
 **Repro**
diff --git a/.github/ISSUE_TEMPLATE/typescript-eslint-utils.md b/.github/ISSUE_TEMPLATE/typescript-eslint-utils.md
index 5b365a85ea8..48bb39e6fe0 100644
--- a/.github/ISSUE_TEMPLATE/typescript-eslint-utils.md
+++ b/.github/ISSUE_TEMPLATE/typescript-eslint-utils.md
@@ -15,7 +15,7 @@ The more relevant information you can include, the faster we can find the issue
 
 <!--
 Make sure you read through our FAQ before posting.
-https://github.com/typescript-eslint/typescript-eslint/blob/issue-template-update/docs/getting-started/linting/FAQ.md
+https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md
 -->
 
 **Repro**
diff --git a/.github/ISSUE_TEMPLATE/typescript-estree.md b/.github/ISSUE_TEMPLATE/typescript-estree.md
index 21f4c800d54..f4a72b75b0e 100644
--- a/.github/ISSUE_TEMPLATE/typescript-estree.md
+++ b/.github/ISSUE_TEMPLATE/typescript-estree.md
@@ -15,7 +15,7 @@ The more relevant information you can include, the faster we can find the issue
 
 <!--
 Make sure you read through our FAQ before posting.
-https://github.com/typescript-eslint/typescript-eslint/blob/issue-template-update/docs/getting-started/linting/FAQ.md
+https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/FAQ.md
 -->
 
 **Repro**

From c49d771ba62f1a21d3c1aec106341daddfcd3c9a Mon Sep 17 00:00:00 2001
From: Nikita Stefaniak <phaux4@gmail.com>
Date: Fri, 3 Apr 2020 23:54:07 +0200
Subject: [PATCH 23/36] feat(eslint-plugin): new rule method-signature-style
 (#1685)

---
 .cspell.json                                  |  24 ++--
 packages/eslint-plugin/README.md              |   1 +
 .../docs/rules/method-signature-style.md      |  83 ++++++++++++
 packages/eslint-plugin/src/configs/all.json   |   1 +
 packages/eslint-plugin/src/rules/index.ts     |   6 +-
 .../src/rules/method-signature-style.ts       | 124 ++++++++++++++++++
 .../rules/method-signature-style.test.ts      | 111 ++++++++++++++++
 7 files changed, 337 insertions(+), 13 deletions(-)
 create mode 100644 packages/eslint-plugin/docs/rules/method-signature-style.md
 create mode 100644 packages/eslint-plugin/src/rules/method-signature-style.ts
 create mode 100644 packages/eslint-plugin/tests/rules/method-signature-style.test.ts

diff --git a/.cspell.json b/.cspell.json
index 7ee50214e7f..9df7d65a1b5 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -35,45 +35,47 @@
     "\\(#.+?\\)"
   ],
   "words": [
-    "ASTs",
     "Airbnb",
     "Airbnb's",
-    "Codecov",
-    "Crockford",
-    "errored",
-    "IDE's",
-    "IIFE",
-    "IIFEs",
-    "OOM",
-    "OOMs",
-    "Premade",
-    "ROADMAP",
+    "ASTs",
     "autofix",
     "autofixers",
     "backticks",
     "bigint",
+    "bivariant",
     "blockless",
     "codebases",
+    "Codecov",
+    "contravariant",
+    "Crockford",
     "declarators",
     "destructure",
     "destructured",
+    "errored",
     "erroring",
     "ESLint",
     "ESLint's",
     "espree",
     "estree",
+    "IDE's",
+    "IIFE",
+    "IIFEs",
     "linebreaks",
     "necroing",
     "nocheck",
     "nullish",
+    "OOM",
+    "OOMs",
     "parameterised",
     "performant",
     "pluggable",
     "postprocess",
+    "Premade",
     "prettier's",
     "recurse",
     "reimplement",
     "resync",
+    "ROADMAP",
     "ruleset",
     "rulesets",
     "superset",
diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
index fa049b2cfb2..92131acf458 100644
--- a/packages/eslint-plugin/README.md
+++ b/packages/eslint-plugin/README.md
@@ -107,6 +107,7 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int
 | [`@typescript-eslint/explicit-module-boundary-types`](./docs/rules/explicit-module-boundary-types.md)                 | Require explicit return and argument types on exported functions' and classes' public class methods                     |                    |          |                   |
 | [`@typescript-eslint/member-delimiter-style`](./docs/rules/member-delimiter-style.md)                                 | Require a specific member delimiter style for interfaces and type literals                                              | :heavy_check_mark: | :wrench: |                   |
 | [`@typescript-eslint/member-ordering`](./docs/rules/member-ordering.md)                                               | Require a consistent member declaration order                                                                           |                    |          |                   |
+| [`@typescript-eslint/method-signature-style`](./docs/rules/method-signature-style.md)                                 | Enforces using a particular method signature syntax.                                                                    |                    | :wrench: |                   |
 | [`@typescript-eslint/naming-convention`](./docs/rules/naming-convention.md)                                           | Enforces naming conventions for everything across a codebase                                                            |                    |          | :thought_balloon: |
 | [`@typescript-eslint/no-base-to-string`](./docs/rules/no-base-to-string.md)                                           | Requires that `.toString()` is only called on objects which provide useful information when stringified                 |                    |          | :thought_balloon: |
 | [`@typescript-eslint/no-dynamic-delete`](./docs/rules/no-dynamic-delete.md)                                           | Disallow the delete operator with computed key expressions                                                              |                    | :wrench: |                   |
diff --git a/packages/eslint-plugin/docs/rules/method-signature-style.md b/packages/eslint-plugin/docs/rules/method-signature-style.md
new file mode 100644
index 00000000000..d760c8d0193
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/method-signature-style.md
@@ -0,0 +1,83 @@
+# Enforces using a particular method signature syntax. (`method-signature-style`)
+
+There are two ways to define an object/interface function property.
+
+```ts
+// method shorthand syntax
+interface T1 {
+  func(arg: string): number;
+}
+
+// regular property with function type
+interface T2 {
+  func: (arg: string) => number;
+}
+```
+
+A good practice is to use the TypeScript's `strict` option (which implies `strictFunctionTypes`) which enables correct typechecking for function properties only (method signatures get old behavior).
+
+TypeScript FAQ:
+
+> A method and a function property of the same type behave differently.
+> Methods are always bivariant in their argument, while function properties are contravariant in their argument under `strictFunctionTypes`.
+
+See the reasoning behind that in the [TypeScript PR for the compiler option](https://github.com/microsoft/TypeScript/pull/18654).
+
+## Options
+
+This rule accepts one string option:
+
+- `"property"`: Enforce using property signature for functions. Use this to enforce maximum correctness together with TypeScript's strict mode.
+- `"method"`: Enforce using method signature for functions. Use this if you aren't using TypeScript's strict mode and prefer this style.
+
+The default is `"property"`.
+
+## Rule Details
+
+Examples of **incorrect** code with `property` option.
+
+```ts
+interface T1 {
+  func(arg: string): number;
+}
+type T2 = {
+  func(arg: boolean): void;
+};
+```
+
+Examples of **correct** code with `property` option.
+
+```ts
+interface T1 {
+  func: (arg: string) => number;
+}
+type T2 = {
+  func: (arg: boolean) => void;
+};
+```
+
+Examples of **incorrect** code with `method` option.
+
+```ts
+interface T1 {
+  func: (arg: string) => number;
+}
+type T2 = {
+  func: (arg: boolean) => void;
+};
+```
+
+Examples of **correct** code with `method` option.
+
+```ts
+interface T1 {
+  func(arg: string): number;
+}
+type T2 = {
+  func(arg: boolean): void;
+};
+```
+
+## When Not To Use It
+
+If you don't want to enforce a particular style for object/interface function types, and/or if you don't use `strictFunctionTypes`, then you don't need this rule.
diff --git a/packages/eslint-plugin/src/configs/all.json b/packages/eslint-plugin/src/configs/all.json
index c5575d4970d..cfcb38ced24 100644
--- a/packages/eslint-plugin/src/configs/all.json
+++ b/packages/eslint-plugin/src/configs/all.json
@@ -24,6 +24,7 @@
     "@typescript-eslint/indent": "error",
     "@typescript-eslint/member-delimiter-style": "error",
     "@typescript-eslint/member-ordering": "error",
+    "@typescript-eslint/method-signature-style": "error",
     "@typescript-eslint/naming-convention": "error",
     "no-array-constructor": "off",
     "@typescript-eslint/no-array-constructor": "error",
diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
index 29db58b681a..332c706c832 100644
--- a/packages/eslint-plugin/src/rules/index.ts
+++ b/packages/eslint-plugin/src/rules/index.ts
@@ -22,6 +22,7 @@ import interfaceNamePrefix from './interface-name-prefix';
 import memberDelimiterStyle from './member-delimiter-style';
 import memberNaming from './member-naming';
 import memberOrdering from './member-ordering';
+import methodSignatureStyle from './method-signature-style';
 import namingConvention from './naming-convention';
 import noArrayConstructor from './no-array-constructor';
 import noBaseToString from './no-base-to-string';
@@ -30,10 +31,10 @@ import noDynamicDelete from './no-dynamic-delete';
 import noEmptyFunction from './no-empty-function';
 import noEmptyInterface from './no-empty-interface';
 import noExplicitAny from './no-explicit-any';
-import noExtraneousClass from './no-extraneous-class';
 import noExtraNonNullAssertion from './no-extra-non-null-assertion';
 import noExtraParens from './no-extra-parens';
 import noExtraSemi from './no-extra-semi';
+import noExtraneousClass from './no-extraneous-class';
 import noFloatingPromises from './no-floating-promises';
 import noForInArray from './no-for-in-array';
 import noImpliedEval from './no-implied-eval';
@@ -99,7 +100,6 @@ export default {
   'ban-ts-comment': banTsComment,
   'ban-ts-ignore': banTsIgnore,
   'ban-types': banTypes,
-  'no-base-to-string': noBaseToString,
   'brace-style': braceStyle,
   camelcase: camelcase,
   'class-name-casing': classNameCasing,
@@ -118,8 +118,10 @@ export default {
   'member-delimiter-style': memberDelimiterStyle,
   'member-naming': memberNaming,
   'member-ordering': memberOrdering,
+  'method-signature-style': methodSignatureStyle,
   'naming-convention': namingConvention,
   'no-array-constructor': noArrayConstructor,
+  'no-base-to-string': noBaseToString,
   'no-dupe-class-members': noDupeClassMembers,
   'no-dynamic-delete': noDynamicDelete,
   'no-empty-function': noEmptyFunction,
diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
new file mode 100644
index 00000000000..6ef8db5a0c9
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -0,0 +1,124 @@
+import {
+  AST_NODE_TYPES,
+  TSESTree,
+} from '@typescript-eslint/experimental-utils';
+import * as util from '../util';
+
+export type Options = ['property' | 'method'];
+
+export type MessageId = 'errorMethod' | 'errorProperty';
+
+export default util.createRule<Options, MessageId>({
+  name: 'method-signature-style',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Enforces using a particular method signature syntax.',
+      category: 'Best Practices',
+      recommended: false,
+    },
+    fixable: 'code',
+    messages: {
+      errorMethod:
+        'Shorthand method signature is forbidden. Use a function property instead.',
+      errorProperty:
+        'Function property signature is forbidden. Use a method shorthand instead.',
+    },
+    schema: [
+      {
+        enum: ['property', 'method'],
+      },
+    ],
+  },
+  defaultOptions: ['property'],
+
+  create(context, [mode]) {
+    const sourceCode = context.getSourceCode();
+
+    function getMethodKey(
+      node: TSESTree.TSMethodSignature | TSESTree.TSPropertySignature,
+    ): string {
+      let key = sourceCode.getText(node.key);
+      if (node.computed) {
+        key = `[${key}]`;
+      }
+      if (node.optional) {
+        key = `${key}?`;
+      }
+      if (node.readonly) {
+        key = `readonly ${key}`;
+      }
+      return key;
+    }
+
+    function getMethodParams(
+      node: TSESTree.TSMethodSignature | TSESTree.TSFunctionType,
+    ): string {
+      let params = '()';
+      if (node.params.length > 0) {
+        params = sourceCode.text.substring(
+          sourceCode.getTokenBefore(node.params[0])!.range[0],
+          sourceCode.getTokenAfter(node.params[node.params.length - 1])!
+            .range[1],
+        );
+      }
+      if (node.typeParameters != null) {
+        const typeParams = sourceCode.getText(node.typeParameters);
+        params = `${typeParams}${params}`;
+      }
+      return params;
+    }
+
+    function getMethodReturnType(
+      node: TSESTree.TSMethodSignature | TSESTree.TSFunctionType,
+    ): string {
+      return sourceCode.getText(node.returnType!.typeAnnotation);
+    }
+
+    return {
+      TSMethodSignature(methodNode): void {
+        if (mode === 'method') {
+          return;
+        }
+
+        context.report({
+          node: methodNode,
+          messageId: 'errorMethod',
+          fix: fixer => {
+            const key = getMethodKey(methodNode);
+            const params = getMethodParams(methodNode);
+            const returnType = getMethodReturnType(methodNode);
+            return fixer.replaceText(
+              methodNode,
+              `${key}: ${params} => ${returnType}`,
+            );
+          },
+        });
+      },
+      TSPropertySignature(propertyNode): void {
+        const typeNode = propertyNode.typeAnnotation?.typeAnnotation;
+        if (typeNode?.type !== AST_NODE_TYPES.TSFunctionType) {
+          return;
+        }
+
+        if (mode === 'property') {
+          return;
+        }
+
+        context.report({
+          node: propertyNode,
+          messageId: 'errorProperty',
+          fix: fixer => {
+            const key = getMethodKey(propertyNode);
+            const params = getMethodParams(typeNode);
+            const returnType = getMethodReturnType(typeNode);
+            return fixer.replaceText(
+              propertyNode,
+              `${key}${params}: ${returnType}`,
+            );
+          },
+        });
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
new file mode 100644
index 00000000000..76003e67d84
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
@@ -0,0 +1,111 @@
+import rule from '../../src/rules/method-signature-style';
+import { batchedSingleLineTests, noFormat, RuleTester } from '../RuleTester';
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+});
+
+ruleTester.run('method-signature-style', rule, {
+  valid: [
+    ...batchedSingleLineTests({
+      code: noFormat`
+        interface Test { f: (a: string) => number }
+        interface Test { ['f']: (a: boolean) => void }
+        interface Test { f: <T>(a: T) => T }
+        interface Test { ['f']: <T extends {}>(a: T, b: T) => T }
+        interface Test { 'f!': </* a */>(/* b */ x: any /* c */) => void }
+        type Test = { readonly f: (a: string) => number }
+        type Test = { ['f']?: (a: boolean) => void }
+        type Test = { readonly f?: <T>(a?: T) => T }
+        type Test = { readonly ['f']?: <T>(a: T, b: T) => T }
+      `,
+    }),
+    ...batchedSingleLineTests({
+      options: ['method'],
+      code: noFormat`
+        interface Test { f(a: string): number }
+        interface Test { ['f'](a: boolean): void }
+        interface Test { f<T>(a: T): T }
+        interface Test { ['f']<T extends {}>(a: T, b: T): T }
+        interface Test { 'f!'</* a */>(/* b */ x: any /* c */): void }
+        type Test = { readonly f(a: string): number }
+        type Test = { ['f']?(a: boolean): void }
+        type Test = { readonly f?<T>(a?: T): T }
+        type Test = { readonly ['f']?<T>(a: T, b: T): T }
+      `,
+    }),
+  ],
+  invalid: [
+    ...batchedSingleLineTests({
+      code: noFormat`
+        interface Test { f(a: string): number }
+        interface Test { ['f'](a: boolean): void }
+        interface Test { f<T>(a: T): T }
+        interface Test { ['f']<T extends {}>(a: T, b: T): T }
+        interface Test { 'f!'</* a */>(/* b */ x: any /* c */): void }
+        type Test = { readonly f(a: string): number }
+        type Test = { ['f']?(a: boolean): void }
+        type Test = { readonly f?<T>(a?: T): T }
+        type Test = { readonly ['f']?<T>(a: T, b: T): T }
+      `,
+      errors: [
+        { messageId: 'errorMethod', line: 2 },
+        { messageId: 'errorMethod', line: 3 },
+        { messageId: 'errorMethod', line: 4 },
+        { messageId: 'errorMethod', line: 5 },
+        { messageId: 'errorMethod', line: 6 },
+        { messageId: 'errorMethod', line: 7 },
+        { messageId: 'errorMethod', line: 8 },
+        { messageId: 'errorMethod', line: 9 },
+        { messageId: 'errorMethod', line: 10 },
+      ],
+      output: noFormat`
+        interface Test { f: (a: string) => number }
+        interface Test { ['f']: (a: boolean) => void }
+        interface Test { f: <T>(a: T) => T }
+        interface Test { ['f']: <T extends {}>(a: T, b: T) => T }
+        interface Test { 'f!': </* a */>(/* b */ x: any /* c */) => void }
+        type Test = { readonly f: (a: string) => number }
+        type Test = { ['f']?: (a: boolean) => void }
+        type Test = { readonly f?: <T>(a?: T) => T }
+        type Test = { readonly ['f']?: <T>(a: T, b: T) => T }
+      `,
+    }),
+    ...batchedSingleLineTests({
+      options: ['method'],
+      code: noFormat`
+        interface Test { f: (a: string) => number }
+        interface Test { ['f']: (a: boolean) => void }
+        interface Test { f: <T>(a: T) => T }
+        interface Test { ['f']: <T extends {}>(a: T, b: T) => T }
+        interface Test { 'f!': </* a */>(/* b */ x: any /* c */) => void }
+        type Test = { readonly f: (a: string) => number }
+        type Test = { ['f']?: (a: boolean) => void }
+        type Test = { readonly f?: <T>(a?: T) => T }
+        type Test = { readonly ['f']?: <T>(a: T, b: T) => T }
+      `,
+      errors: [
+        { messageId: 'errorProperty', line: 2 },
+        { messageId: 'errorProperty', line: 3 },
+        { messageId: 'errorProperty', line: 4 },
+        { messageId: 'errorProperty', line: 5 },
+        { messageId: 'errorProperty', line: 6 },
+        { messageId: 'errorProperty', line: 7 },
+        { messageId: 'errorProperty', line: 8 },
+        { messageId: 'errorProperty', line: 9 },
+        { messageId: 'errorProperty', line: 10 },
+      ],
+      output: noFormat`
+        interface Test { f(a: string): number }
+        interface Test { ['f'](a: boolean): void }
+        interface Test { f<T>(a: T): T }
+        interface Test { ['f']<T extends {}>(a: T, b: T): T }
+        interface Test { 'f!'</* a */>(/* b */ x: any /* c */): void }
+        type Test = { readonly f(a: string): number }
+        type Test = { ['f']?(a: boolean): void }
+        type Test = { readonly f?<T>(a?: T): T }
+        type Test = { readonly ['f']?<T>(a: T, b: T): T }
+      `,
+    }),
+  ],
+});

From 7c11bd66f2d0e5ea9d3943e6b8c66e6ddff50862 Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Fri, 3 Apr 2020 17:47:29 -0700
Subject: [PATCH 24/36] feat(experimental-utils): add types for suggestions
 from CLIEngine (#1844)

---
 packages/experimental-utils/src/ts-eslint/Linter.ts | 8 ++++++++
 packages/experimental-utils/src/ts-eslint/Rule.ts   | 2 --
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/packages/experimental-utils/src/ts-eslint/Linter.ts b/packages/experimental-utils/src/ts-eslint/Linter.ts
index 0233f2f8408..5363059b14d 100644
--- a/packages/experimental-utils/src/ts-eslint/Linter.ts
+++ b/packages/experimental-utils/src/ts-eslint/Linter.ts
@@ -81,6 +81,12 @@ namespace Linter {
     reportUnusedDisableDirectives?: boolean;
   }
 
+  export interface LintSuggestion {
+    desc: string;
+    fix: RuleFix;
+    messageId?: string;
+  }
+
   export interface LintMessage {
     column: number;
     line: number;
@@ -88,11 +94,13 @@ namespace Linter {
     endLine?: number;
     ruleId: string | null;
     message: string;
+    messageId?: string;
     nodeType: string;
     fatal?: true;
     severity: Severity;
     fix?: RuleFix;
     source: string | null;
+    suggestions?: LintSuggestion[];
   }
 
   export interface FixOptions extends LintOptions {
diff --git a/packages/experimental-utils/src/ts-eslint/Rule.ts b/packages/experimental-utils/src/ts-eslint/Rule.ts
index 1f74150292e..8301947ee6b 100644
--- a/packages/experimental-utils/src/ts-eslint/Rule.ts
+++ b/packages/experimental-utils/src/ts-eslint/Rule.ts
@@ -129,8 +129,6 @@ interface ReportDescriptorBase<TMessageIds extends string> {
    */
   messageId: TMessageIds;
   // we disallow this because it's much better to use messageIds for reusable errors that are easily testable
-  // message?: string;
-  // suggestions instead have this property that works the same, but again it's much better to use messageIds
   // desc?: string;
 }
 interface ReportDescriptorWithSuggestion<TMessageIds extends string>

From 16ce74d247781ac890dc0baa30c384f97e581b6b Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Sun, 5 Apr 2020 10:46:39 -0700
Subject: [PATCH 25/36] feat(experimental-utils): update eslint types to match
 v6.8 (#1846)

---
 .../src/ts-eslint-scope/ScopeManager.ts       |  3 +-
 .../src/ts-eslint-scope/analyze.ts            |  3 +-
 .../src/ts-eslint/CLIEngine.ts                | 26 ++++++++++++---
 .../src/ts-eslint/Linter.ts                   | 32 +++++++++++++++----
 .../src/ts-eslint/ParserOptions.ts            | 20 ++++++++++--
 .../experimental-utils/src/ts-eslint/Rule.ts  |  1 +
 .../src/ts-eslint/RuleTester.ts               |  4 +++
 7 files changed, 74 insertions(+), 15 deletions(-)

diff --git a/packages/experimental-utils/src/ts-eslint-scope/ScopeManager.ts b/packages/experimental-utils/src/ts-eslint-scope/ScopeManager.ts
index d1b469a6d4f..9f971d79764 100644
--- a/packages/experimental-utils/src/ts-eslint-scope/ScopeManager.ts
+++ b/packages/experimental-utils/src/ts-eslint-scope/ScopeManager.ts
@@ -1,5 +1,6 @@
 import ESLintScopeManager from 'eslint-scope/lib/scope-manager';
 import { TSESTree } from '../ts-estree';
+import { EcmaVersion } from '../ts-eslint';
 import { Scope } from './Scope';
 import { Variable } from './Variable';
 
@@ -10,7 +11,7 @@ interface ScopeManagerOptions {
   nodejsScope?: boolean;
   sourceType?: 'module' | 'script';
   impliedStrict?: boolean;
-  ecmaVersion?: number;
+  ecmaVersion?: EcmaVersion;
 }
 
 interface ScopeManager {
diff --git a/packages/experimental-utils/src/ts-eslint-scope/analyze.ts b/packages/experimental-utils/src/ts-eslint-scope/analyze.ts
index c4ab4514c8c..9bbe1c1118e 100644
--- a/packages/experimental-utils/src/ts-eslint-scope/analyze.ts
+++ b/packages/experimental-utils/src/ts-eslint-scope/analyze.ts
@@ -1,4 +1,5 @@
 import { analyze as ESLintAnalyze } from 'eslint-scope';
+import { EcmaVersion } from '../ts-eslint';
 import { ScopeManager } from './ScopeManager';
 
 interface AnalysisOptions {
@@ -9,7 +10,7 @@ interface AnalysisOptions {
   impliedStrict?: boolean;
   fallback?: string | ((node: {}) => string[]);
   sourceType?: 'script' | 'module';
-  ecmaVersion?: number;
+  ecmaVersion?: EcmaVersion;
 }
 const analyze = ESLintAnalyze as (
   ast: {},
diff --git a/packages/experimental-utils/src/ts-eslint/CLIEngine.ts b/packages/experimental-utils/src/ts-eslint/CLIEngine.ts
index 46fc36b32ba..4c640d35c91 100644
--- a/packages/experimental-utils/src/ts-eslint/CLIEngine.ts
+++ b/packages/experimental-utils/src/ts-eslint/CLIEngine.ts
@@ -2,11 +2,9 @@
 
 import { CLIEngine as ESLintCLIEngine } from 'eslint';
 import { Linter } from './Linter';
-import { RuleModule, RuleListener } from './Rule';
+import { RuleMetaData, RuleModule, RuleListener } from './Rule';
 
 interface CLIEngine {
-  version: string;
-
   executeOnFiles(patterns: string[]): CLIEngine.LintReport;
 
   resolveFileGlobPatterns(patterns: string[]): string[];
@@ -39,6 +37,7 @@ namespace CLIEngine {
     configFile?: string;
     cwd?: string;
     envs?: string[];
+    errorOnUnmatchedPattern?: boolean;
     extensions?: string[];
     fix?: boolean;
     globals?: string[];
@@ -49,6 +48,7 @@ namespace CLIEngine {
     parser?: string;
     parserOptions?: Linter.ParserOptions;
     plugins?: string[];
+    resolvePluginsRelativeTo?: string;
     rules?: {
       [name: string]: Linter.RuleLevel | Linter.RuleLevelAndOptions;
     };
@@ -73,9 +73,24 @@ namespace CLIEngine {
     warningCount: number;
     fixableErrorCount: number;
     fixableWarningCount: number;
+    usedDeprecatedRules: DeprecatedRuleUse[];
+  }
+
+  export interface DeprecatedRuleUse {
+    ruleId: string;
+    replacedBy: string[];
+  }
+
+  export interface LintResultData<TMessageIds extends string> {
+    rulesMeta: {
+      [ruleId: string]: RuleMetaData<TMessageIds>;
+    };
   }
 
-  export type Formatter = (results: LintResult[]) => string;
+  export type Formatter = <TMessageIds extends string>(
+    results: LintResult[],
+    data?: LintResultData<TMessageIds>,
+  ) => string;
 }
 
 const CLIEngine = ESLintCLIEngine as {
@@ -83,8 +98,9 @@ const CLIEngine = ESLintCLIEngine as {
 
   // static methods
   getErrorResults(results: CLIEngine.LintResult[]): CLIEngine.LintResult[];
-
+  getFormatter(format?: string): CLIEngine.Formatter;
   outputFixes(report: CLIEngine.LintReport): void;
+  version: string;
 };
 
 export { CLIEngine };
diff --git a/packages/experimental-utils/src/ts-eslint/Linter.ts b/packages/experimental-utils/src/ts-eslint/Linter.ts
index 5363059b14d..57b1d23ea6c 100644
--- a/packages/experimental-utils/src/ts-eslint/Linter.ts
+++ b/packages/experimental-utils/src/ts-eslint/Linter.ts
@@ -60,15 +60,35 @@ namespace Linter {
 
   export type RuleLevelAndOptions = [RuleLevel, ...unknown[]];
 
-  export interface Config {
-    rules?: {
-      [name: string]: RuleLevel | RuleLevelAndOptions;
-    };
+  export type RuleEntry = RuleLevel | RuleLevelAndOptions;
+  export type RulesRecord = Partial<Record<string, RuleEntry>>;
+
+  // https://github.com/eslint/eslint/blob/v6.8.0/conf/config-schema.js
+  interface BaseConfig {
+    $schema?: string;
+    env?: { [name: string]: boolean };
+    extends?: string | string[];
+    globals?: { [name: string]: boolean };
+    noInlineConfig?: boolean;
+    overrides?: ConfigOverride[];
     parser?: string;
     parserOptions?: ParserOptions;
+    plugins?: string[];
+    processor?: string;
+    reportUnusedDisableDirectives?: boolean;
     settings?: { [name: string]: unknown };
-    env?: { [name: string]: boolean };
-    globals?: { [name: string]: boolean };
+    rules?: RulesRecord;
+  }
+
+  export interface ConfigOverride extends BaseConfig {
+    excludedFiles?: string | string[];
+    files: string | string[];
+  }
+  export type RuleOverride = ConfigOverride; // TODO - delete this next major
+
+  export interface Config extends BaseConfig {
+    ignorePatterns?: string | string[];
+    root?: boolean;
   }
 
   export type ParserOptions = TSParserOptions;
diff --git a/packages/experimental-utils/src/ts-eslint/ParserOptions.ts b/packages/experimental-utils/src/ts-eslint/ParserOptions.ts
index 0ff55c81c56..4a85f2acab5 100644
--- a/packages/experimental-utils/src/ts-eslint/ParserOptions.ts
+++ b/packages/experimental-utils/src/ts-eslint/ParserOptions.ts
@@ -1,12 +1,28 @@
 import { TSESTreeOptions } from '@typescript-eslint/typescript-estree';
 
+type EcmaVersion =
+  | 3
+  | 5
+  | 6
+  | 7
+  | 8
+  | 9
+  | 10
+  | 11
+  | 2015
+  | 2016
+  | 2017
+  | 2018
+  | 2019
+  | 2020;
+
 interface ParserOptions {
   comment?: boolean;
   ecmaFeatures?: {
     globalReturn?: boolean;
     jsx?: boolean;
   };
-  ecmaVersion?: 3 | 5 | 6 | 7 | 8 | 9 | 10 | 2015 | 2016 | 2017 | 2018 | 2019;
+  ecmaVersion?: EcmaVersion;
   errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
   errorOnUnknownASTType?: boolean;
   extraFileExtensions?: string[];
@@ -25,4 +41,4 @@ interface ParserOptions {
   warnOnUnsupportedTypeScriptVersion?: boolean;
 }
 
-export { ParserOptions };
+export { EcmaVersion, ParserOptions };
diff --git a/packages/experimental-utils/src/ts-eslint/Rule.ts b/packages/experimental-utils/src/ts-eslint/Rule.ts
index 8301947ee6b..61f9cd7611e 100644
--- a/packages/experimental-utils/src/ts-eslint/Rule.ts
+++ b/packages/experimental-utils/src/ts-eslint/Rule.ts
@@ -128,6 +128,7 @@ interface ReportDescriptorBase<TMessageIds extends string> {
    * The messageId which is being reported.
    */
   messageId: TMessageIds;
+
   // we disallow this because it's much better to use messageIds for reusable errors that are easily testable
   // desc?: string;
 }
diff --git a/packages/experimental-utils/src/ts-eslint/RuleTester.ts b/packages/experimental-utils/src/ts-eslint/RuleTester.ts
index 9c63709f37f..41dadcb6363 100644
--- a/packages/experimental-utils/src/ts-eslint/RuleTester.ts
+++ b/packages/experimental-utils/src/ts-eslint/RuleTester.ts
@@ -24,6 +24,8 @@ interface SuggestionOutput<TMessageIds extends string> {
    * Each individual error has its own suggestion, so you have to show the correct, _isolated_ output for each suggestion.
    */
   output: string;
+  // we disallow this because it's much better to use messageIds for reusable errors that are easily testable
+  // desc?: string;
 }
 
 interface InvalidTestCase<
@@ -36,6 +38,8 @@ interface InvalidTestCase<
 
 interface TestCaseError<TMessageIds extends string> {
   messageId: TMessageIds;
+  // we disallow this because it's much better to use messageIds for reusable errors that are easily testable
+  // message?: string;
   data?: Record<string, unknown>;
   type?: AST_NODE_TYPES | AST_TOKEN_TYPES;
   line?: number;

From bed774320f4f9196c98351754f74fbdbbe9309d8 Mon Sep 17 00:00:00 2001
From: James Henry <james@henry.sc>
Date: Mon, 6 Apr 2020 17:01:54 +0000
Subject: [PATCH 26/36] chore: publish v2.27.0

---
 CHANGELOG.md                                 | 24 ++++++++++++++++++++
 lerna.json                                   |  2 +-
 packages/eslint-plugin-internal/CHANGELOG.md | 11 +++++++++
 packages/eslint-plugin-internal/package.json |  4 ++--
 packages/eslint-plugin-tslint/CHANGELOG.md   |  8 +++++++
 packages/eslint-plugin-tslint/package.json   |  6 ++---
 packages/eslint-plugin/CHANGELOG.md          | 21 +++++++++++++++++
 packages/eslint-plugin/package.json          |  4 ++--
 packages/experimental-utils/CHANGELOG.md     | 12 ++++++++++
 packages/experimental-utils/package.json     |  4 ++--
 packages/parser/CHANGELOG.md                 |  8 +++++++
 packages/parser/package.json                 |  8 +++----
 packages/shared-fixtures/CHANGELOG.md        |  8 +++++++
 packages/shared-fixtures/package.json        |  2 +-
 packages/typescript-estree/CHANGELOG.md      | 16 +++++++++++++
 packages/typescript-estree/package.json      |  4 ++--
 16 files changed, 125 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c4f8ac29ce3..17a398ca454 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+
+### Bug Fixes
+
+* **eslint-plugin:** [no-throw-literal] fix crash caused by getBaseTypes ([#1830](https://github.com/typescript-eslint/typescript-eslint/issues/1830)) ([9d53c76](https://github.com/typescript-eslint/typescript-eslint/commit/9d53c761983dd964109b9f13eb9bfe20caf9defb))
+* **eslint-plugin:** [no-unsafe-call] fix incorrect selector ([#1826](https://github.com/typescript-eslint/typescript-eslint/issues/1826)) ([8ec53a3](https://github.com/typescript-eslint/typescript-eslint/commit/8ec53a3579fcb59cdffea0c60fbb755d056f4c8a))
+* **eslint-plugin:** [require-await] handle async generators ([#1782](https://github.com/typescript-eslint/typescript-eslint/issues/1782)) ([9642d9d](https://github.com/typescript-eslint/typescript-eslint/commit/9642d9dce693befac89a4e9d8bf8dd18f4361e2a))
+* **eslint-plugin:** no-explicit-any constructor functions (& mo… ([#1711](https://github.com/typescript-eslint/typescript-eslint/issues/1711)) ([ab8572e](https://github.com/typescript-eslint/typescript-eslint/commit/ab8572e30e14ebda91c8437be5ee35e7dc9add2e))
+* **typescript-estree:** add support for TS3.9 extra file extensions ([#1833](https://github.com/typescript-eslint/typescript-eslint/issues/1833)) ([1f0ff41](https://github.com/typescript-eslint/typescript-eslint/commit/1f0ff41aa1bc3b7c5330b2f5fe22e24bf578a6b2))
+
+
+### Features
+
+* **eslint-plugin:** new rule method-signature-style ([#1685](https://github.com/typescript-eslint/typescript-eslint/issues/1685)) ([c49d771](https://github.com/typescript-eslint/typescript-eslint/commit/c49d771ba62f1a21d3c1aec106341daddfcd3c9a))
+* **eslint-plugin:** sort members alphabetically ([#263](https://github.com/typescript-eslint/typescript-eslint/issues/263)) ([485e902](https://github.com/typescript-eslint/typescript-eslint/commit/485e90213a0f8baac0587f7d56925448883fc5bd))
+* **eslint-plugin-internal:** add plugin-test-formatting rule ([#1821](https://github.com/typescript-eslint/typescript-eslint/issues/1821)) ([9b0023a](https://github.com/typescript-eslint/typescript-eslint/commit/9b0023a4996ecdd7dfcb30abd1678091a78f3064))
+* **experimental-utils:** add types for suggestions from CLIEngine ([#1844](https://github.com/typescript-eslint/typescript-eslint/issues/1844)) ([7c11bd6](https://github.com/typescript-eslint/typescript-eslint/commit/7c11bd66f2d0e5ea9d3943e6b8c66e6ddff50862))
+* **experimental-utils:** update eslint types to match v6.8 ([#1846](https://github.com/typescript-eslint/typescript-eslint/issues/1846)) ([16ce74d](https://github.com/typescript-eslint/typescript-eslint/commit/16ce74d247781ac890dc0baa30c384f97e581b6b))
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 
diff --git a/lerna.json b/lerna.json
index c6d458fa9fa..ecad9d3e932 100644
--- a/lerna.json
+++ b/lerna.json
@@ -1,5 +1,5 @@
 {
-  "version": "2.26.0",
+  "version": "2.27.0",
   "npmClient": "yarn",
   "useWorkspaces": true,
   "stream": true
diff --git a/packages/eslint-plugin-internal/CHANGELOG.md b/packages/eslint-plugin-internal/CHANGELOG.md
index 54cacab8889..00db774efba 100644
--- a/packages/eslint-plugin-internal/CHANGELOG.md
+++ b/packages/eslint-plugin-internal/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+
+### Features
+
+* **eslint-plugin-internal:** add plugin-test-formatting rule ([#1821](https://github.com/typescript-eslint/typescript-eslint/issues/1821)) ([9b0023a](https://github.com/typescript-eslint/typescript-eslint/commit/9b0023a4996ecdd7dfcb30abd1678091a78f3064))
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 **Note:** Version bump only for package @typescript-eslint/eslint-plugin-internal
diff --git a/packages/eslint-plugin-internal/package.json b/packages/eslint-plugin-internal/package.json
index 8e250384428..c70d071c395 100644
--- a/packages/eslint-plugin-internal/package.json
+++ b/packages/eslint-plugin-internal/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin-internal",
-  "version": "2.26.0",
+  "version": "2.27.0",
   "private": true,
   "main": "dist/index.js",
   "scripts": {
@@ -12,7 +12,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.26.0",
+    "@typescript-eslint/experimental-utils": "2.27.0",
     "prettier": "*"
   }
 }
diff --git a/packages/eslint-plugin-tslint/CHANGELOG.md b/packages/eslint-plugin-tslint/CHANGELOG.md
index efd31d32624..feca294a7d3 100644
--- a/packages/eslint-plugin-tslint/CHANGELOG.md
+++ b/packages/eslint-plugin-tslint/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.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+**Note:** Version bump only for package @typescript-eslint/eslint-plugin-tslint
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 
diff --git a/packages/eslint-plugin-tslint/package.json b/packages/eslint-plugin-tslint/package.json
index 9a75ee89cd6..5a3c9134f85 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": "2.26.0",
+  "version": "2.27.0",
   "main": "dist/index.js",
   "typings": "src/index.ts",
   "description": "TSLint wrapper plugin for ESLint",
@@ -31,7 +31,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.26.0",
+    "@typescript-eslint/experimental-utils": "2.27.0",
     "lodash": "^4.17.15"
   },
   "peerDependencies": {
@@ -41,6 +41,6 @@
   },
   "devDependencies": {
     "@types/lodash": "^4.14.149",
-    "@typescript-eslint/parser": "2.26.0"
+    "@typescript-eslint/parser": "2.27.0"
   }
 }
diff --git a/packages/eslint-plugin/CHANGELOG.md b/packages/eslint-plugin/CHANGELOG.md
index 057df3312e5..965a0e893be 100644
--- a/packages/eslint-plugin/CHANGELOG.md
+++ b/packages/eslint-plugin/CHANGELOG.md
@@ -3,6 +3,27 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+
+### Bug Fixes
+
+* **eslint-plugin:** [no-throw-literal] fix crash caused by getBaseTypes ([#1830](https://github.com/typescript-eslint/typescript-eslint/issues/1830)) ([9d53c76](https://github.com/typescript-eslint/typescript-eslint/commit/9d53c761983dd964109b9f13eb9bfe20caf9defb))
+* **eslint-plugin:** [no-unsafe-call] fix incorrect selector ([#1826](https://github.com/typescript-eslint/typescript-eslint/issues/1826)) ([8ec53a3](https://github.com/typescript-eslint/typescript-eslint/commit/8ec53a3579fcb59cdffea0c60fbb755d056f4c8a))
+* **eslint-plugin:** [require-await] handle async generators ([#1782](https://github.com/typescript-eslint/typescript-eslint/issues/1782)) ([9642d9d](https://github.com/typescript-eslint/typescript-eslint/commit/9642d9dce693befac89a4e9d8bf8dd18f4361e2a))
+* **eslint-plugin:** no-explicit-any constructor functions (& mo… ([#1711](https://github.com/typescript-eslint/typescript-eslint/issues/1711)) ([ab8572e](https://github.com/typescript-eslint/typescript-eslint/commit/ab8572e30e14ebda91c8437be5ee35e7dc9add2e))
+
+
+### Features
+
+* **eslint-plugin:** new rule method-signature-style ([#1685](https://github.com/typescript-eslint/typescript-eslint/issues/1685)) ([c49d771](https://github.com/typescript-eslint/typescript-eslint/commit/c49d771ba62f1a21d3c1aec106341daddfcd3c9a))
+* **eslint-plugin:** sort members alphabetically ([#263](https://github.com/typescript-eslint/typescript-eslint/issues/263)) ([485e902](https://github.com/typescript-eslint/typescript-eslint/commit/485e90213a0f8baac0587f7d56925448883fc5bd))
+* **eslint-plugin-internal:** add plugin-test-formatting rule ([#1821](https://github.com/typescript-eslint/typescript-eslint/issues/1821)) ([9b0023a](https://github.com/typescript-eslint/typescript-eslint/commit/9b0023a4996ecdd7dfcb30abd1678091a78f3064))
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 
diff --git a/packages/eslint-plugin/package.json b/packages/eslint-plugin/package.json
index 7689d700f4a..290f200a0d3 100644
--- a/packages/eslint-plugin/package.json
+++ b/packages/eslint-plugin/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "2.26.0",
+  "version": "2.27.0",
   "description": "TypeScript plugin for ESLint",
   "keywords": [
     "eslint",
@@ -41,7 +41,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "2.26.0",
+    "@typescript-eslint/experimental-utils": "2.27.0",
     "functional-red-black-tree": "^1.0.1",
     "regexpp": "^3.0.0",
     "tsutils": "^3.17.1"
diff --git a/packages/experimental-utils/CHANGELOG.md b/packages/experimental-utils/CHANGELOG.md
index 00209a740b2..b874b0c440a 100644
--- a/packages/experimental-utils/CHANGELOG.md
+++ b/packages/experimental-utils/CHANGELOG.md
@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+
+### Features
+
+* **experimental-utils:** add types for suggestions from CLIEngine ([#1844](https://github.com/typescript-eslint/typescript-eslint/issues/1844)) ([7c11bd6](https://github.com/typescript-eslint/typescript-eslint/commit/7c11bd66f2d0e5ea9d3943e6b8c66e6ddff50862))
+* **experimental-utils:** update eslint types to match v6.8 ([#1846](https://github.com/typescript-eslint/typescript-eslint/issues/1846)) ([16ce74d](https://github.com/typescript-eslint/typescript-eslint/commit/16ce74d247781ac890dc0baa30c384f97e581b6b))
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 
diff --git a/packages/experimental-utils/package.json b/packages/experimental-utils/package.json
index 3e0b8a08c98..d1550271300 100644
--- a/packages/experimental-utils/package.json
+++ b/packages/experimental-utils/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/experimental-utils",
-  "version": "2.26.0",
+  "version": "2.27.0",
   "description": "(Experimental) Utilities for working with TypeScript + ESLint together",
   "keywords": [
     "eslint",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@types/json-schema": "^7.0.3",
-    "@typescript-eslint/typescript-estree": "2.26.0",
+    "@typescript-eslint/typescript-estree": "2.27.0",
     "eslint-scope": "^5.0.0",
     "eslint-utils": "^2.0.0"
   },
diff --git a/packages/parser/CHANGELOG.md b/packages/parser/CHANGELOG.md
index 3b604485e8d..c13d0782a4b 100644
--- a/packages/parser/CHANGELOG.md
+++ b/packages/parser/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.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+**Note:** Version bump only for package @typescript-eslint/parser
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 
diff --git a/packages/parser/package.json b/packages/parser/package.json
index b46b229c02e..d59732165ac 100644
--- a/packages/parser/package.json
+++ b/packages/parser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/parser",
-  "version": "2.26.0",
+  "version": "2.27.0",
   "description": "An ESLint custom parser which leverages TypeScript ESTree",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
@@ -43,13 +43,13 @@
   },
   "dependencies": {
     "@types/eslint-visitor-keys": "^1.0.0",
-    "@typescript-eslint/experimental-utils": "2.26.0",
-    "@typescript-eslint/typescript-estree": "2.26.0",
+    "@typescript-eslint/experimental-utils": "2.27.0",
+    "@typescript-eslint/typescript-estree": "2.27.0",
     "eslint-visitor-keys": "^1.1.0"
   },
   "devDependencies": {
     "@types/glob": "^7.1.1",
-    "@typescript-eslint/shared-fixtures": "2.26.0",
+    "@typescript-eslint/shared-fixtures": "2.27.0",
     "glob": "*"
   },
   "peerDependenciesMeta": {
diff --git a/packages/shared-fixtures/CHANGELOG.md b/packages/shared-fixtures/CHANGELOG.md
index f8ee7515974..8ac0c5e5368 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.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+**Note:** Version bump only for package @typescript-eslint/shared-fixtures
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 **Note:** Version bump only for package @typescript-eslint/shared-fixtures
diff --git a/packages/shared-fixtures/package.json b/packages/shared-fixtures/package.json
index b1e8d807285..c36d658dad5 100644
--- a/packages/shared-fixtures/package.json
+++ b/packages/shared-fixtures/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/shared-fixtures",
-  "version": "2.26.0",
+  "version": "2.27.0",
   "private": true,
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
diff --git a/packages/typescript-estree/CHANGELOG.md b/packages/typescript-estree/CHANGELOG.md
index c73e7476362..0d46bcbc15d 100644
--- a/packages/typescript-estree/CHANGELOG.md
+++ b/packages/typescript-estree/CHANGELOG.md
@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.27.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.26.0...v2.27.0) (2020-04-06)
+
+
+### Bug Fixes
+
+* **typescript-estree:** add support for TS3.9 extra file extensions ([#1833](https://github.com/typescript-eslint/typescript-eslint/issues/1833)) ([1f0ff41](https://github.com/typescript-eslint/typescript-eslint/commit/1f0ff41aa1bc3b7c5330b2f5fe22e24bf578a6b2))
+
+
+### Features
+
+* **eslint-plugin:** sort members alphabetically ([#263](https://github.com/typescript-eslint/typescript-eslint/issues/263)) ([485e902](https://github.com/typescript-eslint/typescript-eslint/commit/485e90213a0f8baac0587f7d56925448883fc5bd))
+
+
+
+
+
 # [2.26.0](https://github.com/typescript-eslint/typescript-eslint/compare/v2.25.0...v2.26.0) (2020-03-30)
 
 
diff --git a/packages/typescript-estree/package.json b/packages/typescript-estree/package.json
index 28214f3138c..7667f340314 100644
--- a/packages/typescript-estree/package.json
+++ b/packages/typescript-estree/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "2.26.0",
+  "version": "2.27.0",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "main": "dist/parser.js",
   "types": "dist/parser.d.ts",
@@ -58,7 +58,7 @@
     "@types/lodash": "^4.14.149",
     "@types/semver": "^6.2.0",
     "@types/tmp": "^0.1.0",
-    "@typescript-eslint/shared-fixtures": "2.26.0",
+    "@typescript-eslint/shared-fixtures": "2.27.0",
     "tmp": "^0.1.0",
     "typescript": "*"
   },

From 0fae50b40a9d21d87773d311163cba4e72dff2be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=A9mie=20Astori?= <jeremie@astori.fr>
Date: Tue, 7 Apr 2020 02:41:09 -0400
Subject: [PATCH 27/36] docs(eslint-plugin): [ROADMAP] add
 method-signature-style as alternative to prefer-method-signature (#1858)

---
 packages/eslint-plugin/ROADMAP.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/ROADMAP.md b/packages/eslint-plugin/ROADMAP.md
index 7ca8048769b..93597358ab6 100644
--- a/packages/eslint-plugin/ROADMAP.md
+++ b/packages/eslint-plugin/ROADMAP.md
@@ -184,7 +184,7 @@ It lists all TSLint rules along side rules from the ESLint ecosystem that are th
 | [`one-variable-per-declaration`]    | 🌟  | [`one-var`][one-var]                                                                |
 | [`ordered-imports`]                 | 🌓  | [`import/order`]                                                                    |
 | [`prefer-function-over-method`]     | 🌟  | [`class-methods-use-this`][class-methods-use-this]                                  |
-| [`prefer-method-signature`]         | 🛑  | N/A                                                                                 |
+| [`prefer-method-signature`]         | ✅  | [`@typescript-eslint/method-signature-style`]                                       |
 | [`prefer-switch`]                   | 🛑  | N/A                                                                                 |
 | [`prefer-template`]                 | 🌟  | [`prefer-template`][prefer-template]                                                |
 | [`prefer-while`]                    | 🛑  | N/A                                                                                 |
@@ -597,6 +597,7 @@ Relevant plugins: [`chai-expect-keywords`](https://github.com/gavinaiken/eslint-
 [`@typescript-eslint/consistent-type-definitions`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/consistent-type-definitions.md
 [`@typescript-eslint/explicit-member-accessibility`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/explicit-member-accessibility.md
 [`@typescript-eslint/member-ordering`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/member-ordering.md
+[`@typescript-eslint/method-signature-style`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/method-signature-style.md
 [`@typescript-eslint/no-explicit-any`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-explicit-any.md
 [`@typescript-eslint/no-empty-interface`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-empty-interface.md
 [`@typescript-eslint/no-inferrable-types`]: https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-inferrable-types.md

From 4b799b91fa1d5b8e2595bdbe6449ebc273c507ec Mon Sep 17 00:00:00 2001
From: G r e y <vapurrmaid@pm.me>
Date: Tue, 7 Apr 2020 01:42:28 -0500
Subject: [PATCH 28/36] docs(experimental-utils): fix links to estree pkg
 (#1860)

---
 packages/experimental-utils/README.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/packages/experimental-utils/README.md b/packages/experimental-utils/README.md
index 97d9d5c057b..cba85c84d6e 100644
--- a/packages/experimental-utils/README.md
+++ b/packages/experimental-utils/README.md
@@ -14,17 +14,17 @@ Once it is stable, it will be renamed to `@typescript-eslint/util` for a `3.0.0`
 
 ## Exports
 
-| Name                                                                               | Description                                                                                                                                                                                                                       |
-| ---------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [`ASTUtils`](./src/ast-utils)                                                      | Tools for operating on the ESTree AST. Also includes the [`eslint-utils`](https://www.npmjs.com/package/eslint-utils) package, correctly typed to work with the types found in `TSESTree`                                         |
-| [`ESLintUtils`](./src/eslint-utils)                                                | Tools for creating ESLint rules with TypeScript.                                                                                                                                                                                  |
-| `JSONSchema`                                                                       | Types from the [`@types/json-schema`](https://www.npmjs.com/package/@types/json-schema) package, re-exported to save you having to manually import them. Also ensures you're using the same version of the types as this package. |
-| [`TSESLint`](./src/ts-eslint)                                                      | Types for ESLint, correctly typed to work with the types found in `TSESTree`.                                                                                                                                                     |
-| [`TSESLintScope`](./src/ts-eslint-scope)                                           | The [`eslint-scope`](https://www.npmjs.com/package/eslint-scope) package, correctly typed to work with the types found in both `TSESTree` and `TSESLint`                                                                          |
-| [`TSESTree`](../packages/typescript-estree/src/ts-estree/ts-estree.ts)             | Types for the TypeScript flavor of ESTree created by `@typescript-eslint/typescript-estree`.                                                                                                                                      |
-| [`AST_NODE_TYPES`](../packages/typescript-estree/src/ts-estree/ast-node-types.ts)  | An enum with the names of every single _node_ found in `TSESTree`.                                                                                                                                                                |
-| [`AST_TOKEN_TYPES`](../packages/typescript-estree/src/ts-estree/ast-node-types.ts) | An enum with the names of every single _token_ found in `TSESTree`.                                                                                                                                                               |
-| [`ParserServices`](../packages/typescript-estree/src/ts-estree/parser.ts)          | Typing for the parser services provided when parsing a file using `@typescript-eslint/typescript-estree`.                                                                                                                         |
+| Name                                                                      | Description                                                                                                                                                                                                                       |
+| ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`ASTUtils`](./src/ast-utils)                                             | Tools for operating on the ESTree AST. Also includes the [`eslint-utils`](https://www.npmjs.com/package/eslint-utils) package, correctly typed to work with the types found in `TSESTree`                                         |
+| [`ESLintUtils`](./src/eslint-utils)                                       | Tools for creating ESLint rules with TypeScript.                                                                                                                                                                                  |
+| `JSONSchema`                                                              | Types from the [`@types/json-schema`](https://www.npmjs.com/package/@types/json-schema) package, re-exported to save you having to manually import them. Also ensures you're using the same version of the types as this package. |
+| [`TSESLint`](./src/ts-eslint)                                             | Types for ESLint, correctly typed to work with the types found in `TSESTree`.                                                                                                                                                     |
+| [`TSESLintScope`](./src/ts-eslint-scope)                                  | The [`eslint-scope`](https://www.npmjs.com/package/eslint-scope) package, correctly typed to work with the types found in both `TSESTree` and `TSESLint`                                                                          |
+| [`TSESTree`](../typescript-estree/src/ts-estree/ts-estree.ts)             | Types for the TypeScript flavor of ESTree created by `@typescript-eslint/typescript-estree`.                                                                                                                                      |
+| [`AST_NODE_TYPES`](../typescript-estree/src/ts-estree/ast-node-types.ts)  | An enum with the names of every single _node_ found in `TSESTree`.                                                                                                                                                                |
+| [`AST_TOKEN_TYPES`](../typescript-estree/src/ts-estree/ast-node-types.ts) | An enum with the names of every single _token_ found in `TSESTree`.                                                                                                                                                               |
+| [`ParserServices`](../typescript-estree/src/parser-options.ts)            | Typing for the parser services provided when parsing a file using `@typescript-eslint/typescript-estree`.                                                                                                                         |
 
 ## Contributing
 

From 5832a8643bbe174ec02df5966bb333e506e45f5d Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Tue, 7 Apr 2020 00:00:26 -0700
Subject: [PATCH 29/36] fix(eslint-plugin): [method-signature-style] handle
 multiline params (#1861)

---
 .../src/rules/method-signature-style.ts       |  42 +++--
 .../rules/method-signature-style.test.ts      | 145 ++++++++++++++++--
 2 files changed, 165 insertions(+), 22 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/method-signature-style.ts b/packages/eslint-plugin/src/rules/method-signature-style.ts
index 6ef8db5a0c9..2d6366bbda1 100644
--- a/packages/eslint-plugin/src/rules/method-signature-style.ts
+++ b/packages/eslint-plugin/src/rules/method-signature-style.ts
@@ -4,11 +4,10 @@ import {
 } from '@typescript-eslint/experimental-utils';
 import * as util from '../util';
 
-export type Options = ['property' | 'method'];
+export type Options = [('property' | 'method')?];
+export type MessageIds = 'errorMethod' | 'errorProperty';
 
-export type MessageId = 'errorMethod' | 'errorProperty';
-
-export default util.createRule<Options, MessageId>({
+export default util.createRule<Options, MessageIds>({
   name: 'method-signature-style',
   meta: {
     type: 'suggestion',
@@ -56,10 +55,21 @@ export default util.createRule<Options, MessageId>({
     ): string {
       let params = '()';
       if (node.params.length > 0) {
+        const openingParen = util.nullThrows(
+          sourceCode.getTokenBefore(node.params[0], util.isOpeningParenToken),
+          'Missing opening paren before first parameter',
+        );
+        const closingParen = util.nullThrows(
+          sourceCode.getTokenAfter(
+            node.params[node.params.length - 1],
+            util.isClosingParenToken,
+          ),
+          'Missing closing paren after last parameter',
+        );
+
         params = sourceCode.text.substring(
-          sourceCode.getTokenBefore(node.params[0])!.range[0],
-          sourceCode.getTokenAfter(node.params[node.params.length - 1])!
-            .range[1],
+          openingParen.range[0],
+          closingParen.range[1],
         );
       }
       if (node.typeParameters != null) {
@@ -75,6 +85,18 @@ export default util.createRule<Options, MessageId>({
       return sourceCode.getText(node.returnType!.typeAnnotation);
     }
 
+    function getDelimiter(node: TSESTree.Node): string {
+      const lastToken = sourceCode.getLastToken(node);
+      if (
+        lastToken &&
+        (util.isSemicolonToken(lastToken) || util.isCommaToken(lastToken))
+      ) {
+        return lastToken.value;
+      }
+
+      return '';
+    }
+
     return {
       TSMethodSignature(methodNode): void {
         if (mode === 'method') {
@@ -88,9 +110,10 @@ export default util.createRule<Options, MessageId>({
             const key = getMethodKey(methodNode);
             const params = getMethodParams(methodNode);
             const returnType = getMethodReturnType(methodNode);
+            const delimiter = getDelimiter(methodNode);
             return fixer.replaceText(
               methodNode,
-              `${key}: ${params} => ${returnType}`,
+              `${key}: ${params} => ${returnType}${delimiter}`,
             );
           },
         });
@@ -112,9 +135,10 @@ export default util.createRule<Options, MessageId>({
             const key = getMethodKey(propertyNode);
             const params = getMethodParams(typeNode);
             const returnType = getMethodReturnType(typeNode);
+            const delimiter = getDelimiter(propertyNode);
             return fixer.replaceText(
               propertyNode,
-              `${key}${params}: ${returnType}`,
+              `${key}${params}: ${returnType}${delimiter}`,
             );
           },
         });
diff --git a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
index 76003e67d84..dc938ff8cb9 100644
--- a/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
+++ b/packages/eslint-plugin/tests/rules/method-signature-style.test.ts
@@ -7,19 +7,36 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('method-signature-style', rule, {
   valid: [
-    ...batchedSingleLineTests({
-      code: noFormat`
-        interface Test { f: (a: string) => number }
-        interface Test { ['f']: (a: boolean) => void }
-        interface Test { f: <T>(a: T) => T }
-        interface Test { ['f']: <T extends {}>(a: T, b: T) => T }
-        interface Test { 'f!': </* a */>(/* b */ x: any /* c */) => void }
-        type Test = { readonly f: (a: string) => number }
-        type Test = { ['f']?: (a: boolean) => void }
-        type Test = { readonly f?: <T>(a?: T) => T }
-        type Test = { readonly ['f']?: <T>(a: T, b: T) => T }
-      `,
-    }),
+    `
+interface Test {
+  f: (a: string) => number;
+}
+    `,
+    `
+interface Test {
+  ['f']: (a: boolean) => void;
+}
+    `,
+    `
+interface Test {
+  f: <T>(a: T) => T;
+}
+    `,
+    `
+interface Test {
+  ['f']: <T extends {}>(a: T, b: T) => T;
+}
+    `,
+    // TODO - requires prettier2 to format correctly
+    noFormat`
+interface Test {
+  'f!': </* a */>(/* b */ x: any /* c */) => void;
+}
+    `,
+    'type Test = { readonly f: (a: string) => number };',
+    "type Test = { ['f']?: (a: boolean) => void };",
+    'type Test = { readonly f?: <T>(a?: T) => T };',
+    "type Test = { readonly ['f']?: <T>(a: T, b: T) => T };",
     ...batchedSingleLineTests({
       options: ['method'],
       code: noFormat`
@@ -107,5 +124,107 @@ ruleTester.run('method-signature-style', rule, {
         type Test = { readonly ['f']?<T>(a: T, b: T): T }
       `,
     }),
+    {
+      code: noFormat`
+interface Foo {
+  semi(arg: string): void;
+  comma(arg: string): void,
+  none(arg: string): void
+}
+      `,
+      output: noFormat`
+interface Foo {
+  semi: (arg: string) => void;
+  comma: (arg: string) => void,
+  none: (arg: string) => void
+}
+      `,
+      errors: [
+        {
+          messageId: 'errorMethod',
+          line: 3,
+        },
+        {
+          messageId: 'errorMethod',
+          line: 4,
+        },
+        {
+          messageId: 'errorMethod',
+          line: 5,
+        },
+      ],
+    },
+    {
+      code: noFormat`
+interface Foo {
+  semi: (arg: string) => void;
+  comma: (arg: string) => void,
+  none: (arg: string) => void
+}
+      `,
+      output: noFormat`
+interface Foo {
+  semi(arg: string): void;
+  comma(arg: string): void,
+  none(arg: string): void
+}
+      `,
+      options: ['method'],
+      errors: [
+        {
+          messageId: 'errorProperty',
+          line: 3,
+        },
+        {
+          messageId: 'errorProperty',
+          line: 4,
+        },
+        {
+          messageId: 'errorProperty',
+          line: 5,
+        },
+      ],
+    },
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1857
+    {
+      code: noFormat`
+interface Foo {
+  x(
+    args: Pick<
+      Bar,
+      'one' | 'two' | 'three'
+    >,
+  ): Baz;
+  y(
+    foo: string,
+    bar: number,
+  ): void;
+}
+      `,
+      output: noFormat`
+interface Foo {
+  x: (
+    args: Pick<
+      Bar,
+      'one' | 'two' | 'three'
+    >,
+  ) => Baz;
+  y: (
+    foo: string,
+    bar: number,
+  ) => void;
+}
+      `,
+      errors: [
+        {
+          messageId: 'errorMethod',
+          line: 3,
+        },
+        {
+          messageId: 'errorMethod',
+          line: 9,
+        },
+      ],
+    },
   ],
 });

From 829a2f728f876d356908e2338c2d6620e58f9943 Mon Sep 17 00:00:00 2001
From: G r e y <vapurrmaid@pm.me>
Date: Wed, 8 Apr 2020 11:08:51 -0500
Subject: [PATCH 30/36] fix(eslint-plugin): no-empty-interface autofix (#1865)

Resolves: #1864
---
 .../src/rules/no-empty-interface.ts             | 17 +++++++++++------
 .../tests/rules/no-empty-interface.test.ts      | 15 +++++++++++++++
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index 039415ad68f..2e9e61c1e0e 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -61,13 +61,18 @@ export default util.createRule<Options, MessageIds>({
             context.report({
               node: node.id,
               messageId: 'noEmptyWithSuper',
-              fix: fixer =>
-                fixer.replaceText(
+              fix: fixer => {
+                let typeParam = '';
+                if (node.typeParameters) {
+                  typeParam = sourceCode.getText(node.typeParameters);
+                }
+                return fixer.replaceText(
                   node,
-                  `type ${sourceCode.getText(node.id)} = ${sourceCode.getText(
-                    extend[0],
-                  )}`,
-                ),
+                  `type ${sourceCode.getText(
+                    node.id,
+                  )}${typeParam} = ${sourceCode.getText(extend[0])}`,
+                );
+              },
             });
           }
         }
diff --git a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
index 1a69e06f140..840e729f183 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
@@ -133,5 +133,20 @@ type Foo = R
         },
       ],
     },
+    {
+      code: `
+interface Foo<T> extends Bar<T> {}
+      `,
+      output: noFormat`
+type Foo<T> = Bar<T>
+      `,
+      errors: [
+        {
+          messageId: 'noEmptyWithSuper',
+          line: 2,
+          column: 11,
+        },
+      ],
+    },
   ],
 });

From a49b860cbbb2c7d718b99f561e2fb6eaadf16f17 Mon Sep 17 00:00:00 2001
From: Brad Zacher <brad.zacher@gmail.com>
Date: Thu, 9 Apr 2020 09:45:06 -0700
Subject: [PATCH 31/36] feat(eslint-plugin): add rule no-unsafe-assignment
 (#1694)

---
 packages/eslint-plugin/README.md              |   1 +
 .../docs/rules/no-unsafe-assignment.md        |  62 +++
 .../docs/rules/no-unsafe-call.md              |   2 +-
 packages/eslint-plugin/src/configs/all.json   |   1 +
 packages/eslint-plugin/src/rules/index.ts     |   2 +
 .../src/rules/no-unsafe-assignment.ts         | 370 ++++++++++++++++++
 packages/eslint-plugin/src/util/types.ts      |  49 ++-
 .../tests/rules/no-unsafe-assignment.test.ts  | 327 ++++++++++++++++
 .../src/ts-estree/ts-estree.ts                |   2 +-
 9 files changed, 802 insertions(+), 14 deletions(-)
 create mode 100644 packages/eslint-plugin/docs/rules/no-unsafe-assignment.md
 create mode 100644 packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
 create mode 100644 packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts

diff --git a/packages/eslint-plugin/README.md b/packages/eslint-plugin/README.md
index 92131acf458..809aac848a6 100644
--- a/packages/eslint-plugin/README.md
+++ b/packages/eslint-plugin/README.md
@@ -134,6 +134,7 @@ Pro Tip: For larger codebases you may want to consider splitting our linting int
 | [`@typescript-eslint/no-unnecessary-qualifier`](./docs/rules/no-unnecessary-qualifier.md)                             | Warns when a namespace qualifier is unnecessary                                                                         |                    | :wrench: | :thought_balloon: |
 | [`@typescript-eslint/no-unnecessary-type-arguments`](./docs/rules/no-unnecessary-type-arguments.md)                   | Enforces that type arguments will not be used if not required                                                           |                    | :wrench: | :thought_balloon: |
 | [`@typescript-eslint/no-unnecessary-type-assertion`](./docs/rules/no-unnecessary-type-assertion.md)                   | Warns if a type assertion does not change the type of an expression                                                     | :heavy_check_mark: | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-assignment`](./docs/rules/no-unsafe-assignment.md)                                     | Disallows assigning any to variables and properties                                                                     |                    |          | :thought_balloon: |
 | [`@typescript-eslint/no-unsafe-call`](./docs/rules/no-unsafe-call.md)                                                 | Disallows calling an any type value                                                                                     |                    |          | :thought_balloon: |
 | [`@typescript-eslint/no-unsafe-member-access`](./docs/rules/no-unsafe-member-access.md)                               | Disallows member access on any typed variables                                                                          |                    |          | :thought_balloon: |
 | [`@typescript-eslint/no-unsafe-return`](./docs/rules/no-unsafe-return.md)                                             | Disallows returning any from a function                                                                                 |                    |          | :thought_balloon: |
diff --git a/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md b/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md
new file mode 100644
index 00000000000..5cb6e8d61c2
--- /dev/null
+++ b/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md
@@ -0,0 +1,62 @@
+# Disallows assigning any to variables and properties (`no-unsafe-assignment`)
+
+Despite your best intentions, the `any` type can sometimes leak into your codebase.
+Assigning an `any` typed value to a variable can be hard to pick up on, particularly if it leaks in from an external library. Operations on the variable will not checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase.
+
+## Rule Details
+
+This rule disallows the assigning `any` to a variable, and assigning `any[]` to an array destructuring.
+This rule also compares the assigned type to the variable's declared/inferred return type to ensure you don't return an unsafe `any` in a generic position to a receiver that's expecting a specific type. For example, it will error if you return `Set<any>` from a function declared as returning `Set<string>`.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const x = 1 as any,
+  y = 1 as any;
+const [x] = 1 as any;
+const [x] = [] as any[];
+const [x] = [1 as any];
+[x] = [1] as [any];
+
+function foo(a = 1 as any) {}
+class Foo {
+  constructor(private a = 1 as any) {}
+}
+class Foo {
+  private a = 1 as any;
+}
+
+// generic position examples
+const x: Set<string> = new Set<any>();
+const x: Map<string, string> = new Map<string, any>();
+const x: Set<string[]> = new Set<any[]>();
+const x: Set<Set<Set<string>>> = new Set<Set<Set<any>>>();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const x = 1,
+  y = 1;
+const [x] = [1];
+[x] = [1] as [number];
+
+function foo(a = 1) {}
+class Foo {
+  constructor(private a = 1) {}
+}
+class Foo {
+  private a = 1;
+}
+
+// generic position examples
+const x: Set<string> = new Set<string>();
+const x: Map<string, string> = new Map<string, string>();
+const x: Set<string[]> = new Set<string[]>();
+const x: Set<Set<Set<string>>> = new Set<Set<Set<string>>>();
+```
+
+## Related to
+
+- [`no-explicit-any`](./no-explicit-any.md)
+- TSLint: [`no-unsafe-any`](https://palantir.github.io/tslint/rules/no-unsafe-any/)
diff --git a/packages/eslint-plugin/docs/rules/no-unsafe-call.md b/packages/eslint-plugin/docs/rules/no-unsafe-call.md
index 3c18b7c1ee2..490ff78ced5 100644
--- a/packages/eslint-plugin/docs/rules/no-unsafe-call.md
+++ b/packages/eslint-plugin/docs/rules/no-unsafe-call.md
@@ -1,7 +1,7 @@
 # Disallows calling an any type value (`no-unsafe-call`)
 
 Despite your best intentions, the `any` type can sometimes leak into your codebase.
-Member access on `any` typed variables is not checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase.
+The arguments to, and return value of calling an `any` typed variable are not checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase.
 
 ## Rule Details
 
diff --git a/packages/eslint-plugin/src/configs/all.json b/packages/eslint-plugin/src/configs/all.json
index cfcb38ced24..85cf2e1ecc6 100644
--- a/packages/eslint-plugin/src/configs/all.json
+++ b/packages/eslint-plugin/src/configs/all.json
@@ -63,6 +63,7 @@
     "@typescript-eslint/no-unnecessary-qualifier": "error",
     "@typescript-eslint/no-unnecessary-type-arguments": "error",
     "@typescript-eslint/no-unnecessary-type-assertion": "error",
+    "@typescript-eslint/no-unsafe-assignment": "error",
     "@typescript-eslint/no-unsafe-call": "error",
     "@typescript-eslint/no-unsafe-member-access": "error",
     "@typescript-eslint/no-unsafe-return": "error",
diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
index 332c706c832..15ce8dd1a82 100644
--- a/packages/eslint-plugin/src/rules/index.ts
+++ b/packages/eslint-plugin/src/rules/index.ts
@@ -55,6 +55,7 @@ import noUnnecessaryCondition from './no-unnecessary-condition';
 import noUnnecessaryQualifier from './no-unnecessary-qualifier';
 import noUnnecessaryTypeArguments from './no-unnecessary-type-arguments';
 import noUnnecessaryTypeAssertion from './no-unnecessary-type-assertion';
+import noUnsafeAssignment from './no-unsafe-assignment';
 import noUnsafeCall from './no-unsafe-call';
 import noUnsafeMemberAccess from './no-unsafe-member-access';
 import noUnsafeReturn from './no-unsafe-return';
@@ -151,6 +152,7 @@ export default {
   'no-unnecessary-qualifier': noUnnecessaryQualifier,
   'no-unnecessary-type-arguments': noUnnecessaryTypeArguments,
   'no-unnecessary-type-assertion': noUnnecessaryTypeAssertion,
+  'no-unsafe-assignment': noUnsafeAssignment,
   'no-unsafe-call': noUnsafeCall,
   'no-unsafe-member-access': noUnsafeMemberAccess,
   'no-unsafe-return': noUnsafeReturn,
diff --git a/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
new file mode 100644
index 00000000000..60f7b78acc0
--- /dev/null
+++ b/packages/eslint-plugin/src/rules/no-unsafe-assignment.ts
@@ -0,0 +1,370 @@
+import {
+  TSESTree,
+  AST_NODE_TYPES,
+} from '@typescript-eslint/experimental-utils';
+import * as ts from 'typescript';
+import * as util from '../util';
+
+const enum ComparisonType {
+  /** Do no assignment comparison */
+  None,
+  /** Use the receiver's type for comparison */
+  Basic,
+  /** Use the sender's contextual type for comparison */
+  Contextual,
+}
+
+export default util.createRule({
+  name: 'no-unsafe-assignment',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallows assigning any to variables and properties',
+      category: 'Possible Errors',
+      recommended: false,
+      requiresTypeChecking: true,
+    },
+    messages: {
+      anyAssignment: 'Unsafe assignment of an any value',
+      unsafeArrayPattern: 'Unsafe array destructuring of an any array value',
+      unsafeArrayPatternFromTuple:
+        'Unsafe array destructuring of a tuple element with an any value',
+      unsafeAssignment:
+        'Unsafe asignment of type {{sender}} to a variable of type {{receiver}}',
+      unsafeArraySpread: 'Unsafe spread of an any value in an array',
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const { program, esTreeNodeToTSNodeMap } = util.getParserServices(context);
+    const checker = program.getTypeChecker();
+
+    // returns true if the assignment reported
+    function checkArrayDestructureHelper(
+      receiverNode: TSESTree.Node,
+      senderNode: TSESTree.Node,
+    ): boolean {
+      if (receiverNode.type !== AST_NODE_TYPES.ArrayPattern) {
+        return false;
+      }
+
+      const senderTsNode = esTreeNodeToTSNodeMap.get(senderNode);
+      const senderType = checker.getTypeAtLocation(senderTsNode);
+
+      return checkArrayDestructure(receiverNode, senderType, senderTsNode);
+    }
+
+    // returns true if the assignment reported
+    function checkArrayDestructure(
+      receiverNode: TSESTree.ArrayPattern,
+      senderType: ts.Type,
+      senderNode: ts.Node,
+    ): boolean {
+      // any array
+      // const [x] = ([] as any[]);
+      if (util.isTypeAnyArrayType(senderType, checker)) {
+        context.report({
+          node: receiverNode,
+          messageId: 'unsafeArrayPattern',
+        });
+        return false;
+      }
+
+      if (!checker.isTupleType(senderType)) {
+        return true;
+      }
+
+      const tupleElements = util.getTypeArguments(senderType, checker);
+
+      // tuple with any
+      // const [x] = [1 as any];
+      let didReport = false;
+      for (
+        let receiverIndex = 0;
+        receiverIndex < receiverNode.elements.length;
+        receiverIndex += 1
+      ) {
+        const receiverElement = receiverNode.elements[receiverIndex];
+        if (!receiverElement) {
+          continue;
+        }
+
+        if (receiverElement.type === AST_NODE_TYPES.RestElement) {
+          // don't handle rests as they're not a 1:1 assignment
+          continue;
+        }
+
+        const senderType = tupleElements[receiverIndex] as ts.Type | undefined;
+        if (!senderType) {
+          continue;
+        }
+
+        // check for the any type first so we can handle [[[x]]] = [any]
+        if (util.isTypeAnyType(senderType)) {
+          context.report({
+            node: receiverElement,
+            messageId: 'unsafeArrayPatternFromTuple',
+          });
+          // we want to report on every invalid element in the tuple
+          didReport = true;
+        } else if (receiverElement.type === AST_NODE_TYPES.ArrayPattern) {
+          didReport = checkArrayDestructure(
+            receiverElement,
+            senderType,
+            senderNode,
+          );
+        } else if (receiverElement.type === AST_NODE_TYPES.ObjectPattern) {
+          didReport = checkObjectDestructure(
+            receiverElement,
+            senderType,
+            senderNode,
+          );
+        }
+      }
+
+      return didReport;
+    }
+
+    // returns true if the assignment reported
+    function checkObjectDestructureHelper(
+      receiverNode: TSESTree.Node,
+      senderNode: TSESTree.Node,
+    ): boolean {
+      if (receiverNode.type !== AST_NODE_TYPES.ObjectPattern) {
+        return false;
+      }
+
+      const senderTsNode = esTreeNodeToTSNodeMap.get(senderNode);
+      const senderType = checker.getTypeAtLocation(senderTsNode);
+
+      return checkObjectDestructure(receiverNode, senderType, senderTsNode);
+    }
+
+    // returns true if the assignment reported
+    function checkObjectDestructure(
+      receiverNode: TSESTree.ObjectPattern,
+      senderType: ts.Type,
+      senderNode: ts.Node,
+    ): boolean {
+      const properties = new Map(
+        senderType
+          .getProperties()
+          .map(property => [
+            property.getName(),
+            checker.getTypeOfSymbolAtLocation(property, senderNode),
+          ]),
+      );
+
+      let didReport = false;
+      for (
+        let receiverIndex = 0;
+        receiverIndex < receiverNode.properties.length;
+        receiverIndex += 1
+      ) {
+        const receiverProperty = receiverNode.properties[receiverIndex];
+        if (receiverProperty.type === AST_NODE_TYPES.RestElement) {
+          // don't bother checking rest
+          continue;
+        }
+
+        let key: string;
+        if (receiverProperty.computed === false) {
+          key =
+            receiverProperty.key.type === AST_NODE_TYPES.Identifier
+              ? receiverProperty.key.name
+              : String(receiverProperty.key.value);
+        } else if (receiverProperty.key.type === AST_NODE_TYPES.Literal) {
+          key = String(receiverProperty.key.value);
+        } else if (
+          receiverProperty.key.type === AST_NODE_TYPES.TemplateLiteral &&
+          receiverProperty.key.quasis.length === 1
+        ) {
+          key = String(receiverProperty.key.quasis[0].value.cooked);
+        } else {
+          // can't figure out the name, so skip it
+          continue;
+        }
+
+        const senderType = properties.get(key);
+        if (!senderType) {
+          continue;
+        }
+
+        // check for the any type first so we can handle {x: {y: z}} = {x: any}
+        if (util.isTypeAnyType(senderType)) {
+          context.report({
+            node: receiverProperty.value,
+            messageId: 'unsafeArrayPatternFromTuple',
+          });
+          didReport = true;
+        } else if (
+          receiverProperty.value.type === AST_NODE_TYPES.ArrayPattern
+        ) {
+          didReport = checkArrayDestructure(
+            receiverProperty.value,
+            senderType,
+            senderNode,
+          );
+        } else if (
+          receiverProperty.value.type === AST_NODE_TYPES.ObjectPattern
+        ) {
+          didReport = checkObjectDestructure(
+            receiverProperty.value,
+            senderType,
+            senderNode,
+          );
+        }
+      }
+
+      return didReport;
+    }
+
+    // returns true if the assignment reported
+    function checkAssignment(
+      receiverNode: TSESTree.Node,
+      senderNode: TSESTree.Expression,
+      reportingNode: TSESTree.Node,
+      comparisonType: ComparisonType,
+    ): boolean {
+      const receiverTsNode = esTreeNodeToTSNodeMap.get(receiverNode);
+      const receiverType =
+        comparisonType === ComparisonType.Contextual
+          ? util.getContextualType(checker, receiverTsNode as ts.Expression) ??
+            checker.getTypeAtLocation(receiverTsNode)
+          : checker.getTypeAtLocation(receiverTsNode);
+      const senderType = checker.getTypeAtLocation(
+        esTreeNodeToTSNodeMap.get(senderNode),
+      );
+
+      if (util.isTypeAnyType(senderType)) {
+        context.report({
+          node: reportingNode,
+          messageId: 'anyAssignment',
+        });
+        return true;
+      }
+
+      if (comparisonType === ComparisonType.None) {
+        return false;
+      }
+
+      const result = util.isUnsafeAssignment(senderType, receiverType, checker);
+      if (!result) {
+        return false;
+      }
+
+      const { sender, receiver } = result;
+      context.report({
+        node: reportingNode,
+        messageId: 'unsafeAssignment',
+        data: {
+          sender: checker.typeToString(sender),
+          receiver: checker.typeToString(receiver),
+        },
+      });
+      return true;
+    }
+
+    function getComparisonType(
+      typeAnnotation: TSESTree.TSTypeAnnotation | undefined,
+    ): ComparisonType {
+      return typeAnnotation
+        ? // if there's a type annotation, we can do a comparison
+          ComparisonType.Basic
+        : // no type annotation means the variable's type will just be inferred, thus equal
+          ComparisonType.None;
+    }
+
+    return {
+      'VariableDeclarator[init != null]'(
+        node: TSESTree.VariableDeclarator,
+      ): void {
+        const init = util.nullThrows(
+          node.init,
+          util.NullThrowsReasons.MissingToken(node.type, 'init'),
+        );
+        let didReport = checkAssignment(
+          node.id,
+          init,
+          node,
+          getComparisonType(node.id.typeAnnotation),
+        );
+
+        if (!didReport) {
+          didReport = checkArrayDestructureHelper(node.id, init);
+        }
+        if (!didReport) {
+          checkObjectDestructureHelper(node.id, init);
+        }
+      },
+      'ClassProperty[value != null]'(node: TSESTree.ClassProperty): void {
+        checkAssignment(
+          node.key,
+          node.value!,
+          node,
+          getComparisonType(node.typeAnnotation),
+        );
+      },
+      'AssignmentExpression[operator = "="], AssignmentPattern'(
+        node: TSESTree.AssignmentExpression | TSESTree.AssignmentPattern,
+      ): void {
+        let didReport = checkAssignment(
+          node.left,
+          node.right,
+          node,
+          // the variable already has some form of a type to compare against
+          ComparisonType.Basic,
+        );
+
+        if (!didReport) {
+          didReport = checkArrayDestructureHelper(node.left, node.right);
+        }
+        if (!didReport) {
+          checkObjectDestructureHelper(node.left, node.right);
+        }
+      },
+      // object pattern props are checked via assignments
+      ':not(ObjectPattern) > Property'(node: TSESTree.Property): void {
+        if (node.value.type === AST_NODE_TYPES.AssignmentPattern) {
+          // handled by other selector
+          return;
+        }
+
+        checkAssignment(node.key, node.value, node, ComparisonType.Contextual);
+      },
+      'ArrayExpression > SpreadElement'(node: TSESTree.SpreadElement): void {
+        const resetNode = esTreeNodeToTSNodeMap.get(node.argument);
+        const restType = checker.getTypeAtLocation(resetNode);
+        if (
+          util.isTypeAnyType(restType) ||
+          util.isTypeAnyArrayType(restType, checker)
+        ) {
+          context.report({
+            node: node,
+            messageId: 'unsafeArraySpread',
+          });
+        }
+      },
+      'JSXAttribute[value != null]'(node: TSESTree.JSXAttribute): void {
+        const value = util.nullThrows(
+          node.value,
+          util.NullThrowsReasons.MissingToken(node.type, 'value'),
+        );
+        if (
+          value.type !== AST_NODE_TYPES.JSXExpressionContainer ||
+          value.expression.type === AST_NODE_TYPES.JSXEmptyExpression
+        ) {
+          return;
+        }
+
+        checkAssignment(
+          node.name,
+          value.expression,
+          value.expression,
+          ComparisonType.Contextual,
+        );
+      },
+    };
+  },
+});
diff --git a/packages/eslint-plugin/src/util/types.ts b/packages/eslint-plugin/src/util/types.ts
index f602a1e6a27..ae6ee3843aa 100644
--- a/packages/eslint-plugin/src/util/types.ts
+++ b/packages/eslint-plugin/src/util/types.ts
@@ -1,6 +1,7 @@
 import {
   isCallExpression,
   isJsxExpression,
+  isIdentifier,
   isNewExpression,
   isParameterDeclaration,
   isPropertyDeclaration,
@@ -8,6 +9,7 @@ import {
   isUnionOrIntersectionType,
   isVariableDeclaration,
   unionTypeParts,
+  isPropertyAssignment,
 } from 'tsutils';
 import * as ts from 'typescript';
 
@@ -297,6 +299,18 @@ export function getEqualsKind(operator: string): EqualsKind | undefined {
   }
 }
 
+export function getTypeArguments(
+  type: ts.TypeReference,
+  checker: ts.TypeChecker,
+): readonly ts.Type[] {
+  // getTypeArguments was only added in TS3.7
+  if (checker.getTypeArguments) {
+    return checker.getTypeArguments(type);
+  }
+
+  return type.typeArguments ?? [];
+}
+
 /**
  * @returns true if the type is `any`
  */
@@ -304,6 +318,22 @@ export function isTypeAnyType(type: ts.Type): boolean {
   return isTypeFlagSet(type, ts.TypeFlags.Any);
 }
 
+/**
+ * @returns true if the type is `any[]`
+ */
+export function isTypeAnyArrayType(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+): boolean {
+  return (
+    checker.isArrayType(type) &&
+    isTypeAnyType(
+      // getTypeArguments was only added in TS3.7
+      getTypeArguments(type, checker)[0],
+    )
+  );
+}
+
 export const enum AnyType {
   Any,
   AnyArray,
@@ -321,15 +351,7 @@ export function isAnyOrAnyArrayTypeDiscriminated(
   if (isTypeAnyType(type)) {
     return AnyType.Any;
   }
-  if (
-    checker.isArrayType(type) &&
-    isTypeAnyType(
-      // getTypeArguments was only added in TS3.7
-      checker.getTypeArguments
-        ? checker.getTypeArguments(type)[0]
-        : (type.typeArguments ?? [])[0],
-    )
-  ) {
+  if (isTypeAnyArrayType(type, checker)) {
     return AnyType.AnyArray;
   }
   return AnyType.Safe;
@@ -350,6 +372,10 @@ export function isUnsafeAssignment(
   receiver: ts.Type,
   checker: ts.TypeChecker,
 ): false | { sender: ts.Type; receiver: ts.Type } {
+  if (isTypeAnyType(type) && !isTypeAnyType(receiver)) {
+    return { sender: type, receiver };
+  }
+
   if (isTypeReference(type) && isTypeReference(receiver)) {
     // TODO - figure out how to handle cases like this,
     // where the types are assignable, but not the same type
@@ -386,9 +412,6 @@ export function isUnsafeAssignment(
     return false;
   }
 
-  if (isTypeAnyType(type) && !isTypeAnyType(receiver)) {
-    return { sender: type, receiver };
-  }
   return false;
 }
 
@@ -419,6 +442,8 @@ export function getContextualType(
     return parent.type ? checker.getTypeFromTypeNode(parent.type) : undefined;
   } else if (isJsxExpression(parent)) {
     return checker.getContextualType(parent);
+  } else if (isPropertyAssignment(parent) && isIdentifier(node)) {
+    return checker.getContextualType(node);
   } else if (
     ![ts.SyntaxKind.TemplateSpan, ts.SyntaxKind.JsxExpression].includes(
       parent.kind,
diff --git a/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
new file mode 100644
index 00000000000..708969310ed
--- /dev/null
+++ b/packages/eslint-plugin/tests/rules/no-unsafe-assignment.test.ts
@@ -0,0 +1,327 @@
+import { TSESLint } from '@typescript-eslint/experimental-utils';
+import rule from '../../src/rules/no-unsafe-assignment';
+import {
+  RuleTester,
+  batchedSingleLineTests,
+  getFixturesRootDir,
+  noFormat,
+} from '../RuleTester';
+import {
+  InferMessageIdsTypeFromRule,
+  InferOptionsTypeFromRule,
+} from '../../src/util';
+
+type Options = InferOptionsTypeFromRule<typeof rule>;
+type MessageIds = InferMessageIdsTypeFromRule<typeof rule>;
+type InvalidTest = TSESLint.InvalidTestCase<MessageIds, Options>;
+
+function assignmentTest(
+  tests: [string, number, number, boolean?][],
+): InvalidTest[] {
+  return tests.reduce<InvalidTest[]>(
+    (acc, [assignment, column, endColumn, skipAssignmentExpression]) => {
+      // VariableDeclaration
+      acc.push({
+        code: `const ${assignment}`,
+        errors: [
+          {
+            messageId: 'unsafeArrayPatternFromTuple',
+            line: 1,
+            column: column + 6,
+            endColumn: endColumn + 6,
+          },
+        ],
+      });
+      // AssignmentPattern
+      acc.push({
+        code: `function foo(${assignment}) {}`,
+        errors: [
+          {
+            messageId: 'unsafeArrayPatternFromTuple',
+            line: 1,
+            column: column + 13,
+            endColumn: endColumn + 13,
+          },
+        ],
+      });
+      // AssignmentExpression
+      if (skipAssignmentExpression !== true) {
+        acc.push({
+          code: `(${assignment})`,
+          errors: [
+            {
+              messageId: 'unsafeArrayPatternFromTuple',
+              line: 1,
+              column: column + 1,
+              endColumn: endColumn + 1,
+            },
+          ],
+        });
+      }
+
+      return acc;
+    },
+    [],
+  );
+}
+
+const ruleTester = new RuleTester({
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: './tsconfig.json',
+    tsconfigRootDir: getFixturesRootDir(),
+  },
+});
+
+ruleTester.run('no-unsafe-assignment', rule, {
+  valid: [
+    'const x = 1;',
+    'const x: number = 1;',
+    `
+const x = 1,
+  y = 1;
+    `,
+    'let x;',
+    `
+let x = 1,
+  y;
+    `,
+    'function foo(a = 1) {}',
+    `
+class Foo {
+  constructor(private a = 1) {}
+}
+    `,
+    `
+class Foo {
+  private a = 1;
+}
+    `,
+    'const x: Set<string> = new Set();',
+    'const x: Set<string> = new Set<string>();',
+    'const [x] = [1];',
+    'const [x, ...y] = [1, 2, 3, 4, 5];',
+    'const [x, ...y] = [1];',
+    'function foo(x = 1) {}',
+    'function foo([x] = [1]) {}',
+    'function foo([x, ...y] = [1, 2, 3, 4, 5]) {}',
+    'function foo([x, ...y] = [1]) {}',
+    // this is not checked, because there's no annotation to compare it with
+    'const x = new Set<any>();',
+    'const x = { y: 1 };',
+    'const x: { y: number } = { y: 1 };',
+    'const x = [...[1, 2, 3]];',
+    {
+      code: `
+type Props = { a: string };
+declare function Foo(props: Props): never;
+<Foo a={'foo'} />;
+      `,
+      filename: 'react.tsx',
+    },
+  ],
+  invalid: [
+    ...batchedSingleLineTests({
+      code: noFormat`
+const x = (1 as any);
+const x = (1 as any), y = 1;
+function foo(a = (1 as any)) {}
+class Foo { constructor(private a = (1 as any)) {} }
+class Foo { private a = (1 as any) }
+      `,
+      errors: [
+        {
+          messageId: 'anyAssignment',
+          line: 2,
+          column: 7,
+          endColumn: 21,
+        },
+        {
+          messageId: 'anyAssignment',
+          line: 3,
+          column: 7,
+          endColumn: 21,
+        },
+        {
+          messageId: 'anyAssignment',
+          line: 4,
+          column: 14,
+          endColumn: 28,
+        },
+        {
+          messageId: 'anyAssignment',
+          line: 5,
+          column: 33,
+          endColumn: 47,
+        },
+        {
+          messageId: 'anyAssignment',
+          line: 6,
+          column: 13,
+          endColumn: 35,
+        },
+      ],
+    }),
+    ...batchedSingleLineTests({
+      code: `
+const [x] = 1 as any;
+const [x] = [] as any[];
+      `,
+      errors: [
+        {
+          messageId: 'anyAssignment',
+          line: 2,
+          column: 7,
+          endColumn: 21,
+        },
+        {
+          messageId: 'unsafeArrayPattern',
+          line: 3,
+          column: 7,
+          endColumn: 10,
+        },
+      ],
+    }),
+    ...batchedSingleLineTests({
+      code: noFormat`
+const x: Set<string> = new Set<any>();
+const x: Map<string, string> = new Map<string, any>();
+const x: Set<string[]> = new Set<any[]>();
+const x: Set<Set<Set<string>>> = new Set<Set<Set<any>>>();
+      `,
+      errors: [
+        {
+          messageId: 'unsafeAssignment',
+          data: {
+            sender: 'Set<any>',
+            receiver: 'Set<string>',
+          },
+          line: 2,
+        },
+        {
+          messageId: 'unsafeAssignment',
+          data: {
+            sender: 'Map<string, any>',
+            receiver: 'Map<string, string>',
+          },
+          line: 3,
+        },
+        {
+          messageId: 'unsafeAssignment',
+          data: {
+            sender: 'Set<any[]>',
+            receiver: 'Set<string[]>',
+          },
+          line: 4,
+        },
+        {
+          messageId: 'unsafeAssignment',
+          data: {
+            sender: 'Set<Set<Set<any>>>',
+            receiver: 'Set<Set<Set<string>>>',
+          },
+          line: 5,
+        },
+      ],
+    }),
+    ...assignmentTest([
+      ['[x] = [1] as [any]', 2, 3],
+      ['[[[[x]]]] = [[[[1 as any]]]]', 5, 6],
+      ['[[[[x]]]] = [1 as any]', 2, 9, true],
+      ['[{x}] = [{x: 1}] as [{x: any}]', 3, 4],
+    ]),
+    {
+      // TS treats the assignment pattern weirdly in this case
+      code: '[[[[x]]]] = [1 as any];',
+      errors: [
+        {
+          messageId: 'unsafeAssignment',
+          line: 1,
+          column: 1,
+          endColumn: 23,
+        },
+      ],
+    },
+    ...batchedSingleLineTests({
+      code: `
+const x = [...(1 as any)];
+const x = [...([] as any[])];
+      `,
+      errors: [
+        {
+          messageId: 'unsafeArraySpread',
+          line: 2,
+          column: 12,
+          endColumn: 25,
+        },
+        {
+          messageId: 'unsafeArraySpread',
+          line: 3,
+          column: 12,
+          endColumn: 28,
+        },
+      ],
+    }),
+    ...assignmentTest([
+      ['{x} = {x: 1} as {x: any}', 2, 3],
+      ['{x: y} = {x: 1} as {x: any}', 5, 6],
+      ['{x: {y}} = {x: {y: 1}} as {x: {y: any}}', 6, 7],
+      ['{x: [y]} = {x: {y: 1}} as {x: [any]}', 6, 7],
+    ]),
+    ...batchedSingleLineTests({
+      code: `
+const x = { y: 1 as any };
+const x = { y: { z: 1 as any } };
+const x: { y: Set<Set<Set<string>>> } = { y: new Set<Set<Set<any>>>() };
+const x = { ...(1 as any) };
+      `,
+      errors: [
+        {
+          messageId: 'anyAssignment',
+          line: 2,
+          column: 13,
+          endColumn: 24,
+        },
+        {
+          messageId: 'anyAssignment',
+          line: 3,
+          column: 18,
+          endColumn: 29,
+        },
+        {
+          messageId: 'unsafeAssignment',
+          line: 4,
+          column: 43,
+          endColumn: 70,
+          data: {
+            sender: 'Set<Set<Set<any>>>',
+            receiver: 'Set<Set<Set<string>>>',
+          },
+        },
+        {
+          // spreading an any widens the object type to any
+          messageId: 'anyAssignment',
+          line: 5,
+          column: 7,
+          endColumn: 28,
+        },
+      ],
+    }),
+    {
+      code: `
+type Props = { a: string };
+declare function Foo(props: Props): never;
+<Foo a={1 as any} />;
+      `,
+      filename: 'react.tsx',
+      errors: [
+        {
+          messageId: 'anyAssignment',
+          line: 4,
+          column: 9,
+          endColumn: 17,
+        },
+      ],
+    },
+  ],
+});
diff --git a/packages/typescript-estree/src/ts-estree/ts-estree.ts b/packages/typescript-estree/src/ts-estree/ts-estree.ts
index 24486b974b3..caf979a3012 100644
--- a/packages/typescript-estree/src/ts-estree/ts-estree.ts
+++ b/packages/typescript-estree/src/ts-estree/ts-estree.ts
@@ -764,7 +764,7 @@ export interface AssignmentExpression extends BinaryExpressionBase {
 export interface AssignmentPattern extends BaseNode {
   type: AST_NODE_TYPES.AssignmentPattern;
   left: BindingName;
-  right?: Expression;
+  right: Expression;
   typeAnnotation?: TSTypeAnnotation;
   optional?: boolean;
   decorators?: Decorator[];

From fd75424f56094db9e1b832adc31fa9ab5bc04d31 Mon Sep 17 00:00:00 2001
From: G r e y <vapurrmaid@pm.me>
Date: Sat, 11 Apr 2020 13:05:42 -0500
Subject: [PATCH 32/36] docs(eslint-plugin): fix typos in no-unsafe-assign
 (#1881)

Co-authored-by: Brad Zacher <brad.zacher@gmail.com>
---
 packages/eslint-plugin/docs/rules/no-unsafe-assignment.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md b/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md
index 5cb6e8d61c2..1a452e431eb 100644
--- a/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md
+++ b/packages/eslint-plugin/docs/rules/no-unsafe-assignment.md
@@ -1,12 +1,12 @@
 # Disallows assigning any to variables and properties (`no-unsafe-assignment`)
 
 Despite your best intentions, the `any` type can sometimes leak into your codebase.
-Assigning an `any` typed value to a variable can be hard to pick up on, particularly if it leaks in from an external library. Operations on the variable will not checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase.
+Assigning an `any` typed value to a variable can be hard to pick up on, particularly if it leaks in from an external library. Operations on the variable will not be checked at all by TypeScript, so it creates a potential safety hole, and source of bugs in your codebase.
 
 ## Rule Details
 
-This rule disallows the assigning `any` to a variable, and assigning `any[]` to an array destructuring.
-This rule also compares the assigned type to the variable's declared/inferred return type to ensure you don't return an unsafe `any` in a generic position to a receiver that's expecting a specific type. For example, it will error if you return `Set<any>` from a function declared as returning `Set<string>`.
+This rule disallows assigning `any` to a variable, and assigning `any[]` to an array destructuring.
+This rule also compares the assigned type to the variable's type to ensure you don't assign an unsafe `any` in a generic position to a receiver that's expecting a specific type. For example, it will error if you assign `Set<any>` to a variable declared as `Set<string>`.
 
 Examples of **incorrect** code for this rule:
 

From 62b2278aec0011c93eae17bed8b278114d3379a2 Mon Sep 17 00:00:00 2001
From: G r e y <vapurrmaid@gmail.com>
Date: Sun, 12 Apr 2020 00:07:49 -0500
Subject: [PATCH 33/36] fix(eslint-plugin): [no-empty-interface] use suggestion
 fixer for ambient contexts (#1880)

---
 .../src/rules/no-empty-interface.ts           | 54 ++++++++++++++-----
 .../tests/rules/no-empty-interface.test.ts    | 36 +++++++++++++
 2 files changed, 78 insertions(+), 12 deletions(-)

diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index 2e9e61c1e0e..d279e9bd4f6 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -1,4 +1,8 @@
 import * as util from '../util';
+import {
+  AST_NODE_TYPES,
+  TSESLint,
+} from '@typescript-eslint/experimental-utils';
 
 type Options = [
   {
@@ -43,6 +47,7 @@ export default util.createRule<Options, MessageIds>({
     return {
       TSInterfaceDeclaration(node): void {
         const sourceCode = context.getSourceCode();
+        const filename = context.getFilename();
 
         if (node.body.body.length !== 0) {
           // interface contains members --> Nothing to report
@@ -58,21 +63,46 @@ export default util.createRule<Options, MessageIds>({
         } else if (extend.length === 1) {
           // interface extends exactly 1 interface --> Report depending on rule setting
           if (!allowSingleExtends) {
+            const fix = (fixer: TSESLint.RuleFixer): TSESLint.RuleFix => {
+              let typeParam = '';
+              if (node.typeParameters) {
+                typeParam = sourceCode.getText(node.typeParameters);
+              }
+              return fixer.replaceText(
+                node,
+                `type ${sourceCode.getText(
+                  node.id,
+                )}${typeParam} = ${sourceCode.getText(extend[0])}`,
+              );
+            };
+
+            // Check if interface is within ambient declaration
+            let useAutoFix = true;
+            if (util.isDefinitionFile(filename)) {
+              const scope = context.getScope();
+              if (
+                scope.block.parent &&
+                scope.block.parent.type ===
+                  AST_NODE_TYPES.TSModuleDeclaration &&
+                scope.block.parent.declare
+              ) {
+                useAutoFix = false;
+              }
+            }
+
             context.report({
               node: node.id,
               messageId: 'noEmptyWithSuper',
-              fix: fixer => {
-                let typeParam = '';
-                if (node.typeParameters) {
-                  typeParam = sourceCode.getText(node.typeParameters);
-                }
-                return fixer.replaceText(
-                  node,
-                  `type ${sourceCode.getText(
-                    node.id,
-                  )}${typeParam} = ${sourceCode.getText(extend[0])}`,
-                );
-              },
+              ...(useAutoFix
+                ? { fix }
+                : {
+                    suggest: [
+                      {
+                        messageId: 'noEmptyWithSuper',
+                        fix,
+                      },
+                    ],
+                  }),
             });
           }
         }
diff --git a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
index 840e729f183..d0281ec77a0 100644
--- a/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-empty-interface.test.ts
@@ -148,5 +148,41 @@ type Foo<T> = Bar<T>
         },
       ],
     },
+    {
+      filename: 'test.d.ts',
+      code: `
+declare module FooBar {
+  type Baz = typeof baz;
+  export interface Bar extends Baz {}
+}
+      `.trimRight(),
+      errors: [
+        {
+          messageId: 'noEmptyWithSuper',
+          line: 4,
+          column: 20,
+          endLine: 4,
+          endColumn: 23,
+          suggestions: [
+            {
+              messageId: 'noEmptyWithSuper',
+              output: noFormat`
+declare module FooBar {
+  type Baz = typeof baz;
+  export type Bar = Baz
+}
+              `.trimRight(),
+            },
+          ],
+        },
+      ],
+      // output matches input because a suggestion was made
+      output: `
+declare module FooBar {
+  type Baz = typeof baz;
+  export interface Bar extends Baz {}
+}
+      `.trimRight(),
+    },
   ],
 });

From af2c00de62f7e31eaeb88996ebf3f330cc8473b9 Mon Sep 17 00:00:00 2001
From: garyking <garyking@gmail.com>
Date: Sun, 12 Apr 2020 01:38:59 -0400
Subject: [PATCH 34/36] feat(eslint-plugin): [consistent-type-assertions]
 always allow `const` assertions (#1713)

---
 .../docs/rules/consistent-type-assertions.md  |  2 ++
 .../src/rules/consistent-type-assertions.ts   | 20 +++++++++++++++++--
 .../rules/consistent-type-assertions.test.ts  | 18 +++++++++++++++--
 3 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/packages/eslint-plugin/docs/rules/consistent-type-assertions.md b/packages/eslint-plugin/docs/rules/consistent-type-assertions.md
index cdf0fb7656c..43e67b755b5 100644
--- a/packages/eslint-plugin/docs/rules/consistent-type-assertions.md
+++ b/packages/eslint-plugin/docs/rules/consistent-type-assertions.md
@@ -8,6 +8,8 @@ Type assertions are also commonly referred as "type casting" in TypeScript (even
 
 In addition to ensuring that type assertions are written in a consistent way, this rule also helps make your codebase more type-safe.
 
+`const` assertions, [introduced in TypeScript 3.4](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions), is always allowed by this rule. Examples of it include `let x = "hello" as const;` and `let x = <const>"hello";`.
+
 ## Options
 
 ```ts
diff --git a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
index ae54149d0a7..0620822f83c 100644
--- a/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
+++ b/packages/eslint-plugin/src/rules/consistent-type-assertions.ts
@@ -75,10 +75,27 @@ export default util.createRule<Options, MessageIds>({
   create(context, [options]) {
     const sourceCode = context.getSourceCode();
 
+    function isConst(node: TSESTree.TypeNode): boolean {
+      if (node.type !== AST_NODE_TYPES.TSTypeReference) {
+        return false;
+      }
+
+      return (
+        node.typeName.type === AST_NODE_TYPES.Identifier &&
+        node.typeName.name === 'const'
+      );
+    }
+
     function reportIncorrectAssertionType(
       node: TSESTree.TSTypeAssertion | TSESTree.TSAsExpression,
     ): void {
+      // If this node is `as const`, then don't report an error.
+      if (isConst(node.typeAnnotation)) {
+        return;
+      }
+
       const messageId = options.assertionStyle;
+
       context.report({
         node,
         messageId,
@@ -97,8 +114,7 @@ export default util.createRule<Options, MessageIds>({
         case AST_NODE_TYPES.TSTypeReference:
           return (
             // Ignore `as const` and `<const>`
-            (node.typeName.type === AST_NODE_TYPES.Identifier &&
-              node.typeName.name !== 'const') ||
+            !isConst(node) ||
             // Allow qualified names which have dots between identifiers, `Foo.Bar`
             node.typeName.type === AST_NODE_TYPES.TSQualifiedName
           );
diff --git a/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts b/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
index f885d503091..010bb894ad7 100644
--- a/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
+++ b/packages/eslint-plugin/tests/rules/consistent-type-assertions.test.ts
@@ -9,14 +9,12 @@ const ANGLE_BRACKET_TESTS = `
 const x = <Foo>new Generic<int>();
 const x = <A>b;
 const x = <readonly number[]>[1];
-const x = <const>[1];
 const x = <a | b>('string');
 `;
 const AS_TESTS = `
 const x = new Generic<int>() as Foo;
 const x = b as A;
 const x = [1] as readonly number[];
-const x = [1] as const;
 const x = ('string') as a | b;
 `;
 const OBJECT_LITERAL_AS_CASTS = `
@@ -98,6 +96,22 @@ ruleTester.run('consistent-type-assertions', rule, {
         },
       ],
     }),
+    {
+      code: 'const x = <const>[1];',
+      options: [
+        {
+          assertionStyle: 'never',
+        },
+      ],
+    },
+    {
+      code: 'const x = [1] as const;',
+      options: [
+        {
+          assertionStyle: 'never',
+        },
+      ],
+    },
   ],
   invalid: [
     ...batchedSingleLineTests({

From d44c0f9bed2404ca00b020b35fd825929e213398 Mon Sep 17 00:00:00 2001
From: itowlson <github@hestia.cc>
Date: Sun, 12 Apr 2020 22:09:47 +1200
Subject: [PATCH 35/36] feat(eslint-plugin): [restrict-template-expressions]
 add option `allowAny` (#1762)

---
 .../rules/restrict-template-expressions.md    | 10 ++++
 .../rules/restrict-template-expressions.ts    | 10 +++-
 .../restrict-template-expressions.test.ts     | 46 +++++++++++++++++++
 3 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/packages/eslint-plugin/docs/rules/restrict-template-expressions.md b/packages/eslint-plugin/docs/rules/restrict-template-expressions.md
index 549da98eebd..4c52e74445f 100644
--- a/packages/eslint-plugin/docs/rules/restrict-template-expressions.md
+++ b/packages/eslint-plugin/docs/rules/restrict-template-expressions.md
@@ -59,6 +59,16 @@ const msg1 = `arg = ${arg}`;
 const msg2 = `arg = ${arg || 'not truthy'}`;
 ```
 
+### `allowAny`
+
+Examples of additional **correct** code for this rule with `{ allowAny: true }`:
+
+```ts
+const user = JSON.parse('{ "name": "foo" }');
+const msg1 = `arg = ${user.name}`;
+const msg2 = `arg = ${user.name || 'the user with no name'}`;
+```
+
 ### `allowNullable`
 
 Examples of additional **correct** code for this rule with `{ allowNullable: true }`:
diff --git a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
index 6ff1627daf5..63b257ffe7f 100644
--- a/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
+++ b/packages/eslint-plugin/src/rules/restrict-template-expressions.ts
@@ -10,6 +10,7 @@ type Options = [
     allowNullable?: boolean;
     allowNumber?: boolean;
     allowBoolean?: boolean;
+    allowAny?: boolean;
   },
 ];
 
@@ -32,6 +33,7 @@ export default util.createRule<Options, MessageId>({
       {
         type: 'object',
         properties: {
+          allowAny: { type: 'boolean' },
           allowBoolean: { type: 'boolean' },
           allowNullable: { type: 'boolean' },
           allowNumber: { type: 'boolean' },
@@ -51,6 +53,7 @@ export default util.createRule<Options, MessageId>({
       | 'boolean'
       | 'null'
       | 'undefined'
+      | 'any'
       | 'other';
 
     const allowedTypes: BaseType[] = [
@@ -58,6 +61,7 @@ export default util.createRule<Options, MessageId>({
       ...(options.allowNumber ? (['number', 'bigint'] as const) : []),
       ...(options.allowBoolean ? (['boolean'] as const) : []),
       ...(options.allowNullable ? (['null', 'undefined'] as const) : []),
+      ...(options.allowAny ? (['any'] as const) : []),
     ];
 
     function isAllowedType(types: BaseType[]): boolean {
@@ -127,6 +131,9 @@ export default util.createRule<Options, MessageId>({
       if (type.flags & ts.TypeFlags.Undefined) {
         return ['undefined'];
       }
+      if (type.flags & ts.TypeFlags.Any) {
+        return ['any'];
+      }
 
       if (type.isUnion()) {
         return type.types
@@ -139,7 +146,8 @@ export default util.createRule<Options, MessageId>({
         stringType === 'string' ||
         stringType === 'number' ||
         stringType === 'bigint' ||
-        stringType === 'boolean'
+        stringType === 'boolean' ||
+        stringType === 'any'
       ) {
         return [stringType];
       }
diff --git a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
index 3e18e7ac1b1..6a2861efa32 100644
--- a/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
+++ b/packages/eslint-plugin/tests/rules/restrict-template-expressions.test.ts
@@ -115,6 +115,43 @@ ruleTester.run('restrict-template-expressions', rule, {
         }
       `,
     },
+    // allowAny
+    {
+      options: [{ allowAny: true }],
+      code: `
+        const arg: any = 123;
+        const msg = \`arg = \${arg}\`;
+      `,
+    },
+    {
+      options: [{ allowAny: true }],
+      code: `
+        const arg: any = undefined;
+        const msg = \`arg = \${arg || 'some-default'}\`;
+      `,
+    },
+    {
+      options: [{ allowAny: true }],
+      code: `
+        const user = JSON.parse('{ "name": "foo" }');
+        const msg = \`arg = \${user.name}\`;
+      `,
+    },
+    {
+      options: [{ allowAny: true }],
+      code: `
+        const user = JSON.parse('{ "name": "foo" }');
+        const msg = \`arg = \${user.name || 'the user with no name'}\`;
+      `,
+    },
+    {
+      options: [{ allowAny: true }],
+      code: `
+        function test<T extends any>(arg: T) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+    },
     // allowNullable
     {
       options: [{ allowNullable: true }],
@@ -208,5 +245,14 @@ ruleTester.run('restrict-template-expressions', rule, {
       `,
       errors: [{ messageId: 'invalidType', line: 3, column: 27 }],
     },
+    {
+      options: [{ allowNumber: true, allowBoolean: true, allowNullable: true }],
+      code: `
+        function test(arg: any) {
+          return \`arg = \${arg}\`;
+        }
+      `,
+      errors: [{ messageId: 'invalidType', line: 3, column: 27 }],
+    },
   ],
 });

From 6b4680b6e7343d9d98fa1de170f387a36d98b73e Mon Sep 17 00:00:00 2001
From: Zen <843968788@qq.com>
Date: Mon, 13 Apr 2020 03:50:13 +0800
Subject: [PATCH 36/36] fix(eslint-plugin): [unbound-method] ignore assignments
 _to_ methods (#1736)

---
 .../eslint-plugin/src/rules/unbound-method.ts |  3 ++
 .../tests/rules/unbound-method.test.ts        | 31 +++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/packages/eslint-plugin/src/rules/unbound-method.ts b/packages/eslint-plugin/src/rules/unbound-method.ts
index 1e9cb9131ad..629aec50cca 100644
--- a/packages/eslint-plugin/src/rules/unbound-method.ts
+++ b/packages/eslint-plugin/src/rules/unbound-method.ts
@@ -241,6 +241,9 @@ function isSafeUse(node: TSESTree.Node): boolean {
     case AST_NODE_TYPES.BinaryExpression:
       return ['instanceof', '==', '!=', '===', '!=='].includes(parent.operator);
 
+    case AST_NODE_TYPES.AssignmentExpression:
+      return parent.operator === '=' && node === parent.left;
+
     case AST_NODE_TYPES.TSNonNullExpression:
     case AST_NODE_TYPES.TSAsExpression:
     case AST_NODE_TYPES.TSTypeAssertion:
diff --git a/packages/eslint-plugin/tests/rules/unbound-method.test.ts b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
index 10f0b549762..733b81e16b1 100644
--- a/packages/eslint-plugin/tests/rules/unbound-method.test.ts
+++ b/packages/eslint-plugin/tests/rules/unbound-method.test.ts
@@ -147,6 +147,9 @@ ruleTester.run('unbound-method', rule, {
 
       "typeof ContainsMethods.boundStatic === 'function';",
       "typeof ContainsMethods.unboundStatic === 'function';",
+
+      'instance.unbound = () => {};',
+      'instance.unbound = instance.unbound.bind(instance);',
     ].map(addContainsMethodsClass),
     `
 interface RecordA {
@@ -211,6 +214,15 @@ const x: OptionalMethod = {};
 declare const myCondition: boolean;
 if (myCondition || x.mightBeDefined) {
   console.log('hello world');
+}
+    `,
+    // https://github.com/typescript-eslint/typescript-eslint/issues/1256
+    `
+class A {
+  unbound(): void {
+    this.unbound = undefined;
+    this.unbound = this.unbound.bind(this);
+  }
 }
     `,
   ],
@@ -336,5 +348,24 @@ const x = CommunicationError.prototype.foo;
         },
       ],
     },
+    {
+      code: `
+class Foo {
+  unbound() {}
+}
+const instance = new Foo();
+
+let x;
+
+x = instance.unbound; // THIS SHOULD ERROR
+instance.unbound = x; // THIS SHOULD NOT
+      `,
+      errors: [
+        {
+          line: 9,
+          messageId: 'unbound',
+        },
+      ],
+    },
   ],
 });